var luciferimpl = { };

var org_emergent_lucidity_lucifer_Lucifer = {
    __gwt_initHandlers: function()
    {

    },

    onScriptLoad: function(getinstancefunc)
    {
        luciferimpl = getinstancefunc();
    }
};
(function(){
var $wnd = null;
var $doc = null;
var $moduleName, $moduleBase;
var _, package_com_google_gwt_core_client_ = 'com.google.gwt.core.client.', package_com_google_gwt_lang_ = 'com.google.gwt.lang.', package_java_io_ = 'java.io.', package_java_lang_ = 'java.lang.', package_org_emergent_lucidity_lucifer_client_ = 'org.emergent.lucidity.lucifer.client.', package_org_emergent_lucidity_lucifer_client_bc_ = 'org.emergent.lucidity.lucifer.client.bc.', package_org_emergent_lucidity_lucifer_client_jzlib_ = 'org.emergent.lucidity.lucifer.client.jzlib.', package_org_emergent_lucidity_lucifer_client_util_ = 'org.emergent.lucidity.lucifer.client.util.';
function nullMethod(){
}

function Object_0(){
}

_ = Object_0.prototype = {};
_.typeName$ = package_java_lang_ + 'Object';
_.typeId$ = 1;
function getTypeName(o){
  return o == null?null:o.typeName$;
}

function $Throwable(this$static, message){
  this$static.message_0 = message;
  return this$static;
}

function $toString_0(this$static){
  var className, msg;
  className = getTypeName(this$static);
  msg = this$static.message_0;
  if (msg !== null) {
    return className + ': ' + msg;
  }
   else {
    return className;
  }
}

function Throwable(){
}

_ = Throwable.prototype = new Object_0();
_.typeName$ = package_java_lang_ + 'Throwable';
_.typeId$ = 3;
_.message_0 = null;
function $Exception(this$static, message){
  $Throwable(this$static, message);
  return this$static;
}

function Exception(){
}

_ = Exception.prototype = new Throwable();
_.typeName$ = package_java_lang_ + 'Exception';
_.typeId$ = 4;
function $RuntimeException(this$static, message){
  $Exception(this$static, message);
  return this$static;
}

function RuntimeException(){
}

_ = RuntimeException.prototype = new Exception();
_.typeName$ = package_java_lang_ + 'RuntimeException';
_.typeId$ = 5;
function $JavaScriptException(this$static, name, description){
  $RuntimeException(this$static, 'JavaScript ' + name + ' exception: ' + description);
  return this$static;
}

function JavaScriptException(){
}

_ = JavaScriptException.prototype = new RuntimeException();
_.typeName$ = package_com_google_gwt_core_client_ + 'JavaScriptException';
_.typeId$ = 6;
function JavaScriptObject(){
}

_ = JavaScriptObject.prototype = new Object_0();
_.typeName$ = package_com_google_gwt_core_client_ + 'JavaScriptObject';
_.typeId$ = 7;
function $Array(this$static, length, typeId, queryId, typeName){
  this$static.length_0 = length;
  this$static.queryId = queryId;
  this$static.typeName$ = typeName;
  this$static.typeId$ = typeId;
  return this$static;
}

function _set(array, index, value){
  return array[index] = value;
}

function getIntValue(values, index){
  return values[index];
}

function getValue(values, index){
  return values[index];
}

function getValueCount(values){
  return values.length;
}

function initDims_0(typeName, typeIdExprs, queryIdExprs, dimExprs, defaultValue){
  return initDims(typeName, typeIdExprs, queryIdExprs, dimExprs, 0, getValueCount(dimExprs), defaultValue);
}

function initDims(typeName, typeIdExprs, queryIdExprs, dimExprs, index, count, defaultValue){
  var i, length, result;
  if ((length = getIntValue(dimExprs, index)) < 0) {
    throw new NegativeArraySizeException();
  }
  result = $Array(new Array_0(), length, getIntValue(typeIdExprs, index), getIntValue(queryIdExprs, index), typeName);
  ++index;
  if (index < count) {
    typeName = $substring(typeName, 1);
    for (i = 0; i < length; ++i) {
      _set(result, i, initDims(typeName, typeIdExprs, queryIdExprs, dimExprs, index, count, defaultValue));
    }
  }
   else {
    for (i = 0; i < length; ++i) {
      _set(result, i, defaultValue);
    }
  }
  return result;
}

function initValues(typeName, typeId, queryId, values){
  var i, length, result;
  length = getValueCount(values);
  result = $Array(new Array_0(), length, typeId, queryId, typeName);
  for (i = 0; i < length; ++i) {
    _set(result, i, getValue(values, i));
  }
  return result;
}

function setCheck(array, index, value){
  if (value !== null && array.queryId != 0 && !instanceOf(value, array.queryId)) {
    throw new ArrayStoreException();
  }
  return _set(array, index, value);
}

function Array_0(){
}

_ = Array_0.prototype = new Object_0();
_.typeName$ = package_com_google_gwt_lang_ + 'Array';
_.typeId$ = 0;
function canCast(srcId, dstId){
  return !(!(srcId && typeIdArray[srcId][dstId]));
}

function dynamicCast(src, dstId){
  if (src != null)
    canCast(src.typeId$, dstId) || throwClassCastException();
  return src;
}

function instanceOf(src, dstId){
  return src != null && canCast(src.typeId$, dstId);
}

function narrow_byte(x){
  return x << 24 >> 24;
}

function narrow_char(x){
  return x & 65535;
}

function narrow_int(x){
  return ~(~x);
}

function narrow_short(x){
  return x << 16 >> 16;
}

function round_int(x){
  if (x > ($clinit_17() , MAX_VALUE))
    return $clinit_17() , MAX_VALUE;
  if (x < ($clinit_17() , MIN_VALUE))
    return $clinit_17() , MIN_VALUE;
  return x >= 0?Math.floor(x):Math.ceil(x);
}

function throwClassCastException(){
  throw new ClassCastException();
}

var typeIdArray;
function caught(e){
  if (instanceOf(e, 3)) {
    return e;
  }
  return $JavaScriptException(new JavaScriptException(), javaScriptExceptionName(e), javaScriptExceptionDescription(e));
}

function javaScriptExceptionDescription(e){
  return e.message;
}

function javaScriptExceptionName(e){
  return e.name;
}

function OutputStream(){
}

_ = OutputStream.prototype = new Object_0();
_.typeName$ = package_java_io_ + 'OutputStream';
_.typeId$ = 0;
function FilterOutputStream(){
}

_ = FilterOutputStream.prototype = new OutputStream();
_.typeName$ = package_java_io_ + 'FilterOutputStream';
_.typeId$ = 0;
function PrintStream(){
}

_ = PrintStream.prototype = new FilterOutputStream();
_.typeName$ = package_java_io_ + 'PrintStream';
_.typeId$ = 0;
function ArrayStoreException(){
}

_ = ArrayStoreException.prototype = new RuntimeException();
_.typeName$ = package_java_lang_ + 'ArrayStoreException';
_.typeId$ = 8;
function ClassCastException(){
}

_ = ClassCastException.prototype = new RuntimeException();
_.typeName$ = package_java_lang_ + 'ClassCastException';
_.typeId$ = 9;
function $IllegalArgumentException(this$static, message){
  $RuntimeException(this$static, message);
  return this$static;
}

function IllegalArgumentException(){
}

_ = IllegalArgumentException.prototype = new RuntimeException();
_.typeName$ = package_java_lang_ + 'IllegalArgumentException';
_.typeId$ = 10;
function $IllegalStateException(this$static, s){
  $RuntimeException(this$static, s);
  return this$static;
}

function IllegalStateException(){
}

_ = IllegalStateException.prototype = new RuntimeException();
_.typeName$ = package_java_lang_ + 'IllegalStateException';
_.typeId$ = 11;
function IndexOutOfBoundsException(){
}

_ = IndexOutOfBoundsException.prototype = new RuntimeException();
_.typeName$ = package_java_lang_ + 'IndexOutOfBoundsException';
_.typeId$ = 12;
function $clinit_21(){
  $clinit_21 = nullMethod;
  {
    initNative();
  }
}

function initNative(){
  $clinit_21();
  floatRegex = /^[+-]?\d*\.?\d*(e[+-]?\d+)?$/i;
}

var floatRegex = null;
function $clinit_17(){
  $clinit_17 = nullMethod;
  $clinit_21();
}

var MAX_VALUE = 2147483647, MIN_VALUE = (-2147483648);
function max(x, y){
  return x > y?x:y;
}

function NegativeArraySizeException(){
}

_ = NegativeArraySizeException.prototype = new RuntimeException();
_.typeName$ = package_java_lang_ + 'NegativeArraySizeException';
_.typeId$ = 13;
function NullPointerException(){
}

_ = NullPointerException.prototype = new RuntimeException();
_.typeName$ = package_java_lang_ + 'NullPointerException';
_.typeId$ = 14;
function $charAt(this$static, index){
  return this$static.charCodeAt(index);
}

function $equals(this$static, other){
  if (!instanceOf(other, 1))
    return false;
  return __equals(this$static, other);
}

function $length(this$static){
  return this$static.length;
}

function $substring(this$static, beginIndex){
  return this$static.substr(beginIndex, this$static.length - beginIndex);
}

function $substring_0(this$static, beginIndex, endIndex){
  return this$static.substr(beginIndex, endIndex - beginIndex);
}

function __equals(me, other){
  return String(me) == other;
}

function valueOf(x){
  return String.fromCharCode(x);
}

_ = String.prototype;
_.typeName$ = package_java_lang_ + 'String';
_.typeId$ = 2;
function $StringBuffer(this$static){
  $assign(this$static);
  return this$static;
}

function $append(this$static, x){
  return $append_0(this$static, valueOf(x));
}

function $append_0(this$static, toAppend){
  if (toAppend === null) {
    toAppend = 'null';
  }
  var last = this$static.js.length - 1;
  var lastLength = this$static.js[last].length;
  if (this$static.length > lastLength * lastLength) {
    this$static.js[last] = this$static.js[last] + toAppend;
  }
   else {
    this$static.js.push(toAppend);
  }
  this$static.length += toAppend.length;
  return this$static;
}

function $assign(this$static){
  $assign_0(this$static, '');
}

function $assign_0(this$static, s){
  this$static.js = [s];
  this$static.length = s.length;
}

function $toString(this$static){
  this$static.normalize();
  return this$static.js[0];
}

function normalize(){
  if (this.js.length > 1) {
    this.js = [this.js.join('')];
    this.length = this.js[0].length;
  }
}

function StringBuffer(){
}

_ = StringBuffer.prototype = new Object_0();
_.normalize = normalize;
_.typeName$ = package_java_lang_ + 'StringBuffer';
_.typeId$ = 0;
function $clinit_26(){
  $clinit_26 = nullMethod;
  out_0 = new PrintStream();
}

function currentTimeMillis(){
  $clinit_26();
  return new Date().getTime();
}

var out_0;
function $doTheWildThingOnMyLeg(this$static){
  try {
    var ivbytes = ['\x0B', 'l', 'F', '\x9B', '\xF8', '^', '\xDD', 'B'].join();
    var keybytes = ['\x1F', '\n', 'd', 'm', '\xB5', 'R', '\xF5', '\xE2', '\xA8', 'r', '\xB3', '\xE5', '\xE5', '\x10', '0', '3'].join();
    var encbytes = ['\xBF', '2', '\xDE', '\xD1', '\xFD', '\xE8', '\xD5', 'h', 'j', '\xB2', '\x94', '\xAA', '8', '\xD3', ' ', '\xA0', '\x82', '\\', 'n', '\x1F', '\x8C', '\xAF', '\xA4', '\xD2', '%', '\xF3', '\xBB', '\xDE', '\xEC', '\xB1', '\xE7', 'J', '\xD5', '\xEA', '\xBF', '<', '\xC0', 'o', '\xCE', '7', '\x92', '\xCB', 'w', 'J', '8', '\x9D', '\xDC', '\xC2', '\xC4', '\xB1', '\xE9', '\x85', 'U', 'F'].join();
    var expected = ['\0', '\xFA', '\x03', '\xD0', '\x96', 'c', 's', '\xB9', 'z', 'h', '&', '\xD3', 'N', '1', '\xF4', '\xD7', '_', '\x8C', '\xB0', '|', '\x1C', '\xEF', '\x8C', '\x8F', '\b', '4', '\xBD', '\x16', 'o', 'U', '\x9A', '|', '\x9C', 'J', '\xBB', '\xFD', '\x8F', '\r', '\x14', '#', '\x15', '\x02', ')', '6', '\x1F', '\xB3', '\xFB', '3', '\x85', '\xF2', '\xAC', 'K', '\x89', '\x94'].join();
    var lucimpl = getLuciferInstance();
    var testresult = lucimpl.decryptString(0, encbytes, keybytes, ivbytes);
    alert('test matches: ' + (expected == testresult));
    keybytes = ['\x1F', '\n', 'd', 'm', '\xB5', 'R', '\xF5', '\xE2', '\x1F', '\n', 'd', 'm', '\xB5', 'R', '\xF5', '\xE2', '\x1F', '\n', 'd', 'm', '\xB5', 'R', '\xF5', '\xE2', '\xA8', 'r', '\xB3', '\xE5', '\xE5', '\x10', '0', '3'].join();
    testresult = lucimpl.encryptString(0, encbytes, keybytes, ivbytes);
    alert('test matches: ' + (expected == testresult));
    testresult = lucimpl.inflateString(2, testinput);
    testresult = lucimpl.deflateString(2, testinput);
    testresult = lucimpl.hashString(2, testinput);
    lucimpl.updateEntropy(999);
    testresult = lucimpl.randomString(2, true);
  }
   catch (e) {
    alert(e);
  }
}

function $onModuleLoad(this$static){
  $doTheWildThingOnMyLeg(this$static);
}

function Lucifer(){
}

_ = Lucifer.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_ + 'Lucifer';
_.typeId$ = 0;
function $$init(this$static){
  this$static.rand = getInstance();
}

function $LuciferImpl(this$static){
  $$init(this$static);
  return this$static;
}

function arraycopy(src, srcPos, dest, destPos, length){
  var ii;
  for (ii = 0; ii < length; ii++) {
    dest[ii + destPos] = src[ii + srcPos];
  }
}

function arraycopy_0(src, srcPos, dest, destPos, length){
  var ii;
  for (ii = 0; ii < length; ii++) {
    dest[ii + destPos] = src[ii + srcPos];
  }
}

function bytes2string(input){
  var buf, i;
  buf = $StringBuffer(new StringBuffer());
  for (i = 0; i < input.length_0; i++) {
    $append(buf, narrow_char(input[i] & 255));
  }
  return $toString(buf);
}

function cryptString(encrypt, pgpcfb, algo, ciphertext, keystr, ivstr){
  var $e0, blockcount, blocksize, c, data, e, encData, engine, i, ivBytes, keyBytes, offset, params, retval;
  try {
    if (ivstr !== null) {
      if ($equals('undefined', ivstr)) {
        ivstr = null;
      }
    }
    switch (algo) {
      case 2:
        engine = $DESedeEngine(new DESedeEngine());
        break;
      case 3:
        engine = $CAST5Engine(new CAST5Engine());
        break;
      case 4:
        engine = $BlowfishEngine(new BlowfishEngine());
        break;
      case 7:
      case 8:
      case 9:
        engine = $AESEngine(new AESEngine());
        break;
      case 10:
        engine = $TwofishEngine(new TwofishEngine());
        break;
      default:throw $RuntimeException(new RuntimeException(), 'bad algo: ' + algo);
    }
    blocksize = engine.getBlockSize();
    if (pgpcfb) {
      c = $OpenPGPCFBBlockCipher(new OpenPGPCFBBlockCipher(), engine);
    }
     else {
      c = $CFBBlockCipher(new CFBBlockCipher(), engine, blocksize * 8);
    }
    if (ivstr === null) {
      ivBytes = initDims_0('[B', [0], [(-1)], [blocksize], 0);
    }
     else {
      ivBytes = string2bytes(ivstr);
    }
    keyBytes = string2bytes(keystr);
    encData = string2bytes(ciphertext);
    params = $ParamsImpl(new ParamsImpl(), keyBytes, ivBytes);
    c.init(encrypt, params);
    data = null;
    blockcount = round_int(encData.length_0 / blocksize);
    if (encData.length_0 % blocksize != 0) {
      blockcount++;
      data = initDims_0('[B', [0], [(-1)], [blockcount * blocksize], 0);
      arraycopy(encData, 0, data, 0, encData.length_0);
      encData = data;
    }
    data = initDims_0('[B', [0], [(-1)], [blockcount * blocksize], 0);
    for (i = 0; i < blockcount; i++) {
      offset = i * blocksize;
      c.processBlock(encData, offset, data, offset);
    }
    retval = bytes2string(data);
    return '\0' + $substring_0(retval, 0, encData.length_0);
  }
   catch ($e0) {
    $e0 = caught($e0);
    if (instanceOf($e0, 4)) {
      e = $e0;
      return '\x01' + $toString_0(e);
    }
     else 
      throw $e0;
  }
}

function decryptString(pgpcfb, algo, ciphertext, keystr, ivstr){
  return cryptString(false, pgpcfb, algo, ciphertext, keystr, ivstr);
}

function deflateString(algorithm, input){
  var $e0, baos, buf, bytes, e, ii, is, newbytes;
  if (algorithm == 0)
    return '\0' + input;
  try {
    buf = $StringBuffer(new StringBuffer());
    $append(buf, 0);
    bytes = initDims_0('[B', [0], [(-1)], [$length(input)], 0);
    for (ii = 0; ii < $length(input); ii++) {
      bytes[ii] = narrow_byte($charAt(input, ii) & 255);
    }
    baos = $ByteArrayOutputStream(new ByteArrayOutputStream());
    is = $ZOutputStream(new ZOutputStream(), baos, (-1), algorithm == 1);
    $write_1(is, bytes);
    $flush(is);
    $close(is);
    newbytes = $toByteArray(baos);
    for (ii = 0; ii < newbytes.length_0; ii++) {
      $append(buf, narrow_char(newbytes[ii]));
    }
    return $toString(buf);
  }
   catch ($e0) {
    $e0 = caught($e0);
    if (instanceOf($e0, 3)) {
      e = $e0;
      return '\x01' + $toString_0(e);
    }
     else 
      throw $e0;
  }
}

function encryptString(pgpcfb, algo, ciphertext, keystr, ivstr){
  return cryptString(true, pgpcfb, algo, ciphertext, keystr, ivstr);
}

function getLuciferInstance(){
  return $LuciferImpl(new LuciferImpl());
}

function hashString(algorithm, input){
  var $e0, e;
  try {
    throw $RuntimeException(new RuntimeException(), 'hi there!');
  }
   catch ($e0) {
    $e0 = caught($e0);
    if (instanceOf($e0, 3)) {
      e = $e0;
      return '\x01' + $toString_0(e);
    }
     else 
      throw $e0;
  }
}

function inflateString(algorithm, input){
  var $e0, buf, bytes, e, ii, is, thebyte;
  if (algorithm == 0)
    return '\0' + input;
  try {
    buf = $StringBuffer(new StringBuffer());
    $append(buf, 0);
    bytes = initDims_0('[B', [0], [(-1)], [$length(input)], 0);
    for (ii = 0; ii < $length(input); ii++) {
      bytes[ii] = narrow_byte($charAt(input, ii) & 255);
    }
    is = $ZInputStream(new ZInputStream(), $ByteArrayInputStream(new ByteArrayInputStream(), bytes), algorithm == 1);
    while ((thebyte = $read(is)) != (-1)) {
      $append(buf, narrow_char(thebyte));
    }
    return $toString(buf);
  }
   catch ($e0) {
    $e0 = caught($e0);
    if (instanceOf($e0, 3)) {
      e = $e0;
      return '\x01' + $toString_0(e);
    }
     else 
      throw $e0;
  }
}

function randomString(len, nozero){
  var data, ii, retval;
  data = initDims_0('[B', [0], [(-1)], [len], 0);
  $nextBytes(this.rand, data);
  if (nozero) {
    for (ii = 0; ii < data.length_0; ii++) {
      if (data[ii] == 0)
        data[ii] = 1;
    }
  }
  retval = bytes2string(data);
  return '\0' + retval;
}

function string2bytes(input){
  var bytes, ii;
  bytes = initDims_0('[B', [0], [(-1)], [$length(input)], 0);
  for (ii = 0; ii < $length(input); ii++) {
    bytes[ii] = narrow_byte($charAt(input, ii));
  }
  return bytes;
}

function updateEntropy(inseed){
  var seed;
  seed = currentTimeMillis();
  if (inseed != 0) {
    seed <<= 32;
    seed += inseed;
  }
  $setSeed(this.rand, seed);
}

function LuciferImpl(){
}

_ = LuciferImpl.prototype = new Object_0();
_.decryptString = decryptString;
_.deflateString = deflateString;
_.encryptString = encryptString;
_.hashString = hashString;
_.inflateString = inflateString;
_.randomString = randomString;
_.updateEntropy = updateEntropy;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_ + 'LuciferImpl';
_.typeId$ = 0;
function $clinit_30(){
  $clinit_30 = nullMethod;
  S = initValues('[B', 0, (-1), [99, 124, 119, 123, (-14), 107, 111, (-59), 48, 1, 103, 43, (-2), (-41), (-85), 118, (-54), (-126), (-55), 125, (-6), 89, 71, (-16), (-83), (-44), (-94), (-81), (-100), (-92), 114, (-64), (-73), (-3), (-109), 38, 54, 63, (-9), (-52), 52, (-91), (-27), (-15), 113, (-40), 49, 21, 4, (-57), 35, (-61), 24, (-106), 5, (-102), 7, 18, (-128), (-30), (-21), 39, (-78), 117, 9, (-125), 44, 26, 27, 110, 90, (-96), 82, 59, (-42), (-77), 41, (-29), 47, (-124), 83, (-47), 0, (-19), 32, (-4), (-79), 91, 106, (-53), (-66), 57, 74, 76, 88, (-49), (-48), (-17), (-86), (-5), 67, 77, 51, (-123), 69, (-7), 2, 127, 80, 60, (-97), (-88), 81, (-93), 64, (-113), (-110), (-99), 56, (-11), (-68), (-74), (-38), 33, 16, (-1), (-13), (-46), (-51), 12, 19, (-20), 95, (-105), 68, 23, (-60), (-89), 126, 61, 100, 93, 25, 115, 96, (-127), 79, (-36), 34, 42, (-112), (-120), 70, (-18), (-72), 20, (-34), 94, 11, (-37), (-32), 50, 58, 10, 73, 6, 36, 92, (-62), (-45), (-84), 98, (-111), (-107), (-28), 121, (-25), (-56), 55, 109, (-115), (-43), 78, (-87), 108, 86, (-12), (-22), 101, 122, (-82), 8, (-70), 120, 37, 46, 28, (-90), (-76), (-58), (-24), (-35), 116, 31, 75, (-67), (-117), (-118), 112, 62, (-75), 102, 72, 3, (-10), 14, 97, 53, 87, (-71), (-122), (-63), 29, (-98), (-31), (-8), (-104), 17, 105, (-39), (-114), (-108), (-101), 30, (-121), (-23), (-50), 85, 40, (-33), (-116), (-95), (-119), 13, (-65), (-26), 66, 104, 65, (-103), 45, 15, (-80), 84, (-69), 22]);
  Si = initValues('[B', 0, (-1), [82, 9, 106, (-43), 48, 54, (-91), 56, (-65), 64, (-93), (-98), (-127), (-13), (-41), (-5), 124, (-29), 57, (-126), (-101), 47, (-1), (-121), 52, (-114), 67, 68, (-60), (-34), (-23), (-53), 84, 123, (-108), 50, (-90), (-62), 35, 61, (-18), 76, (-107), 11, 66, (-6), (-61), 78, 8, 46, (-95), 102, 40, (-39), 36, (-78), 118, 91, (-94), 73, 109, (-117), (-47), 37, 114, (-8), (-10), 100, (-122), 104, (-104), 22, (-44), (-92), 92, (-52), 93, 101, (-74), (-110), 108, 112, 72, 80, (-3), (-19), (-71), (-38), 94, 21, 70, 87, (-89), (-115), (-99), (-124), (-112), (-40), (-85), 0, (-116), (-68), (-45), 10, (-9), (-28), 88, 5, (-72), (-77), 69, 6, (-48), 44, 30, (-113), (-54), 63, 15, 2, (-63), (-81), (-67), 3, 1, 19, (-118), 107, 58, (-111), 17, 65, 79, 103, (-36), (-22), (-105), (-14), (-49), (-50), (-16), (-76), (-26), 115, (-106), (-84), 116, 34, (-25), (-83), 53, (-123), (-30), (-7), 55, (-24), 28, 117, (-33), 110, 71, (-15), 26, 113, 29, 41, (-59), (-119), 111, (-73), 98, 14, (-86), 24, (-66), 27, (-4), 86, 62, 75, (-58), (-46), 121, 32, (-102), (-37), (-64), (-2), 120, (-51), 90, (-12), 31, (-35), (-88), 51, (-120), 7, (-57), 49, (-79), 18, 16, 89, 39, (-128), (-20), 95, 96, 81, 127, (-87), 25, (-75), 74, 13, 45, (-27), 122, (-97), (-109), (-55), (-100), (-17), (-96), (-32), 59, 77, (-82), 42, (-11), (-80), (-56), (-21), (-69), 60, (-125), 83, (-103), 97, 23, 43, 4, 126, (-70), 119, (-42), 38, (-31), 105, 20, 99, 85, 33, 12, 125]);
  rcon = initValues('[I', 19, (-1), [1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108, 216, 171, 77, 154, 47, 94, 188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145]);
  T0 = initValues('[I', 19, (-1), [(-1520213050), (-2072216328), (-1720223762), (-1921287178), 234025727, (-1117033514), (-1318096930), 1422247313, 1345335392, 50397442, (-1452841010), 2099981142, 436141799, 1658312629, (-424957107), (-1703512340), 1170918031, (-1652391393), 1086966153, (-2021818886), 368769775, (-346465870), (-918075506), 200339707, (-324162239), 1742001331, (-39673249), (-357585083), (-1080255453), (-140204973), (-1770884380), 1539358875, (-1028147339), 486407649, (-1366060227), 1780885068, 1513502316, 1094664062, 49805301, 1338821763, 1546925160, (-190470831), 887481809, 150073849, (-1821281822), 1943591083, 1395732834, 1058346282, 201589768, 1388824469, 1696801606, 1589887901, 672667696, (-1583966665), 251987210, (-1248159185), 151455502, 907153956, (-1686077413), 1038279391, 652995533, 1764173646, (-843926913), (-1619692054), 453576978, (-1635548387), 1949051992, 773462580, 756751158, (-1301385508), (-296068428), (-73359269), (-162377052), 1295727478, 1641469623, (-827083907), 2066295122, 1055122397, 1898917726, (-1752923117), (-179088474), 1758581177, 0, 753790401, 1612718144, 536673507, (-927878791), (-312779850), (-1100322092), 1187761037, (-641810841), 1262041458, (-565556588), (-733197160), (-396863312), 1255133061, 1808847035, 720367557, (-441800113), 385612781, (-985447546), (-682799718), 1429418854, (-1803188975), (-817543798), 284817897, 100794884, (-2122350594), (-263171936), 1144798328, (-1163944155), (-475486133), (-212774494), (-22830243), (-1069531008), (-1970303227), (-1382903233), (-1130521311), 1211644016, 83228145, (-541279133), (-1044990345), 1977277103, 1663115586, 806359072, 452984805, 250868733, 1842533055, 1288555905, 336333848, 890442534, 804056259, (-513843266), (-1567123659), (-867941240), 957814574, 1472513171, (-223893675), (-2105639172), 1195195770, (-1402706744), (-413311558), 723065138, (-1787595802), (-1604296512), (-1736343271), (-783331426), 2145180835, 1713513028, 2116692564, (-1416589253), (-2088204277), (-901364084), 703524551, (-742868885), 1007948840, 2044649127, (-497131844), 487262998, 1994120109, 1004593371, 1446130276, 1312438900, 503974420, (-615954030), 168166924, 1814307912, (-463709000), 1573044895, 1859376061, (-273896381), (-1503501628), (-1466855111), (-1533700815), 937747667, (-1954973198), 854058965, 1137232011, 1496790894, (-1217565222), (-1936880383), 1691735473, (-766620004), (-525751991), (-1267962664), (-95005012), 133494003, 636152527, (-1352309302), (-1904575756), (-374428089), 403179536, (-709182865), (-2005370640), 1864705354, 1915629148, 605822008, (-240736681), (-944458637), 1371981463, 602466507, 2094914977, (-1670089496), 555687742, (-582268010), (-591544991), (-2037675251), (-2054518257), (-1871679264), 1111375484, (-994724495), (-1436129588), (-666351472), 84083462, 32962295, 302911004, (-1553899070), 1597322602, (-111716434), (-793134743), (-1853454825), 1489093017, 656219450, (-1180787161), 954327513, 335083755, (-1281845205), 856756514, (-1150719534), 1893325225, (-1987146233), (-1483434957), (-1231316179), 572399164, (-1836611819), 552200649, 1238290055, (-11184726), 2015897680, 2061492133, (-1886614525), (-123625127), (-2138470135), 386731290, (-624967835), 837215959, (-968736124), (-1201116976), (-1019133566), (-1332111063), 1999449434, 286199582, (-877612933), (-61582168), (-692339859), 974525996]);
  Tinv0 = initValues('[I', 19, (-1), [1353184337, 1399144830, (-1012656358), (-1772214470), (-882136261), (-247096033), (-1420232020), (-1828461749), 1442459680, (-160598355), (-1854485368), 625738485, (-52959921), (-674551099), (-2143013594), (-1885117771), 1230680542, 1729870373, (-1743852987), (-507445667), 41234371, 317738113, (-1550367091), (-956705941), (-413167869), (-1784901099), (-344298049), (-631680363), 763608788, (-752782248), 694804553, 1154009486, 1787413109, 2021232372, 1799248025, (-579749593), (-1236278850), 397248752, 1722556617, (-1271214467), 407560035, (-2110711067), 1613975959, 1165972322, (-529046351), (-2068943941), 480281086, (-1809118983), 1483229296, 436028815, (-2022908268), (-1208452270), 601060267, (-503166094), 1468997603, 715871590, 120122290, 63092015, (-1703164538), (-1526188077), (-226023376), (-1297760477), (-1167457534), 1552029421, 723308426, (-1833666137), (-252573709), (-1578997426), (-839591323), (-708967162), 526529745, (-1963022652), (-1655493068), (-1604979806), 853641733, 1978398372, 971801355, (-1427152832), 111112542, 1360031421, (-108388034), 1023860118, (-1375387939), 1186850381, (-1249028975), 90031217, 1876166148, (-15380384), 620468249, (-1746289194), (-868007799), 2006899047, (-1119688528), (-2004121337), 945494503, (-605108103), 1191869601, (-384875908), (-920746760), 0, (-2088337399), 1223502642, (-1401941730), 1316117100, (-67170563), 1446544655, 517320253, 658058550, 1691946762, 564550760, (-783000677), 976107044, (-1318647284), 266819475, (-761860428), (-1634624741), 1338359936, (-1574904735), 1766553434, 370807324, 179999714, (-450191168), 1138762300, 488053522, 185403662, (-1379431438), (-1180125651), (-928440812), (-2061897385), 1275557295, (-1143105042), (-44007517), (-1624899081), (-1124765092), (-985962940), 880737115, 1982415755, (-590994485), 1761406390, 1676797112, (-891538985), 277177154, 1076008723, 538035844, 2099530373, (-130171950), 288553390, 1839278535, 1261411869, (-214912292), (-330136051), (-790380169), 1813426987, (-1715900247), (-95906799), 577038663, (-997393240), 440397984, (-668172970), (-275762398), (-951170681), (-1043253031), (-22885748), 906744984, (-813566554), 685669029, 646887386, (-1530942145), (-459458004), 227702864, (-1681105046), 1648787028, (-1038905866), (-390539120), 1593260334, (-173030526), (-1098883681), 2090061929, (-1456614033), (-1290656305), 999926984, (-1484974064), 1852021992, 2075868123, 158869197, (-199730834), 28809964, (-1466282109), 1701746150, 2129067946, 147831841, (-420997649), (-644094022), (-835293366), (-737566742), (-696471511), (-1347247055), 824393514, 815048134, (-1067015627), 935087732, (-1496677636), (-1328508704), 366520115, 1251476721, (-136647615), 240176511, 804688151, (-1915335306), 1303441219, 1414376140, (-553347356), (-474623586), 461924940, (-1205916479), 2136040774, 82468509, 1563790337, 1937016826, 776014843, 1511876531, 1389550482, 861278441, 323475053, (-1939744870), 2047648055, (-1911228327), (-1992551445), (-299390514), 902390199, (-303751967), 1018251130, 1507840668, 1064563285, 2043548696, (-1086863501), (-355600557), 1537932639, 342834655, (-2032450440), (-2114736182), 1053059257, 741614648, 1598071746, 1925389590, 203809468, (-1958134744), 1100287487, 1895934009, (-558691320), (-1662733096), (-1866377628), 1636092795, 1890988757, 1952214088, 1113045200]);
}

function $AESEngine(this$static){
  $clinit_30();
  return this$static;
}

function $FFmulX(this$static, x){
  return (x & 2139062143) << 1 ^ ((x & (-2139062144)) >>> 7) * 27;
}

function $decryptBlock(this$static, KW){
  var r, r0, r1, r2, r3;
  this$static.C0 ^= KW[this$static.ROUNDS][0];
  this$static.C1 ^= KW[this$static.ROUNDS][1];
  this$static.C2 ^= KW[this$static.ROUNDS][2];
  this$static.C3 ^= KW[this$static.ROUNDS][3];
  r = this$static.ROUNDS - 1;
  while (r > 1) {
    r0 = Tinv0[this$static.C0 & 255] ^ $shift(this$static, Tinv0[this$static.C3 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[this$static.C2 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[this$static.C1 >> 24 & 255], 8) ^ KW[r][0];
    r1 = Tinv0[this$static.C1 & 255] ^ $shift(this$static, Tinv0[this$static.C0 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[this$static.C3 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[this$static.C2 >> 24 & 255], 8) ^ KW[r][1];
    r2 = Tinv0[this$static.C2 & 255] ^ $shift(this$static, Tinv0[this$static.C1 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[this$static.C0 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[this$static.C3 >> 24 & 255], 8) ^ KW[r][2];
    r3 = Tinv0[this$static.C3 & 255] ^ $shift(this$static, Tinv0[this$static.C2 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[this$static.C1 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[this$static.C0 >> 24 & 255], 8) ^ KW[r--][3];
    this$static.C0 = Tinv0[r0 & 255] ^ $shift(this$static, Tinv0[r3 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[r2 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[r1 >> 24 & 255], 8) ^ KW[r][0];
    this$static.C1 = Tinv0[r1 & 255] ^ $shift(this$static, Tinv0[r0 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[r3 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[r2 >> 24 & 255], 8) ^ KW[r][1];
    this$static.C2 = Tinv0[r2 & 255] ^ $shift(this$static, Tinv0[r1 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[r0 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[r3 >> 24 & 255], 8) ^ KW[r][2];
    this$static.C3 = Tinv0[r3 & 255] ^ $shift(this$static, Tinv0[r2 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[r1 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[r0 >> 24 & 255], 8) ^ KW[r--][3];
  }
  r0 = Tinv0[this$static.C0 & 255] ^ $shift(this$static, Tinv0[this$static.C3 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[this$static.C2 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[this$static.C1 >> 24 & 255], 8) ^ KW[r][0];
  r1 = Tinv0[this$static.C1 & 255] ^ $shift(this$static, Tinv0[this$static.C0 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[this$static.C3 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[this$static.C2 >> 24 & 255], 8) ^ KW[r][1];
  r2 = Tinv0[this$static.C2 & 255] ^ $shift(this$static, Tinv0[this$static.C1 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[this$static.C0 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[this$static.C3 >> 24 & 255], 8) ^ KW[r][2];
  r3 = Tinv0[this$static.C3 & 255] ^ $shift(this$static, Tinv0[this$static.C2 >> 8 & 255], 24) ^ $shift(this$static, Tinv0[this$static.C1 >> 16 & 255], 16) ^ $shift(this$static, Tinv0[this$static.C0 >> 24 & 255], 8) ^ KW[r][3];
  this$static.C0 = Si[r0 & 255] & 255 ^ (Si[r3 >> 8 & 255] & 255) << 8 ^ (Si[r2 >> 16 & 255] & 255) << 16 ^ Si[r1 >> 24 & 255] << 24 ^ KW[0][0];
  this$static.C1 = Si[r1 & 255] & 255 ^ (Si[r0 >> 8 & 255] & 255) << 8 ^ (Si[r3 >> 16 & 255] & 255) << 16 ^ Si[r2 >> 24 & 255] << 24 ^ KW[0][1];
  this$static.C2 = Si[r2 & 255] & 255 ^ (Si[r1 >> 8 & 255] & 255) << 8 ^ (Si[r0 >> 16 & 255] & 255) << 16 ^ Si[r3 >> 24 & 255] << 24 ^ KW[0][2];
  this$static.C3 = Si[r3 & 255] & 255 ^ (Si[r2 >> 8 & 255] & 255) << 8 ^ (Si[r1 >> 16 & 255] & 255) << 16 ^ Si[r0 >> 24 & 255] << 24 ^ KW[0][3];
}

function $encryptBlock(this$static, KW){
  var r, r0, r1, r2, r3;
  this$static.C0 ^= KW[0][0];
  this$static.C1 ^= KW[0][1];
  this$static.C2 ^= KW[0][2];
  this$static.C3 ^= KW[0][3];
  r = 1;
  while (r < this$static.ROUNDS - 1) {
    r0 = T0[this$static.C0 & 255] ^ $shift(this$static, T0[this$static.C1 >> 8 & 255], 24) ^ $shift(this$static, T0[this$static.C2 >> 16 & 255], 16) ^ $shift(this$static, T0[this$static.C3 >> 24 & 255], 8) ^ KW[r][0];
    r1 = T0[this$static.C1 & 255] ^ $shift(this$static, T0[this$static.C2 >> 8 & 255], 24) ^ $shift(this$static, T0[this$static.C3 >> 16 & 255], 16) ^ $shift(this$static, T0[this$static.C0 >> 24 & 255], 8) ^ KW[r][1];
    r2 = T0[this$static.C2 & 255] ^ $shift(this$static, T0[this$static.C3 >> 8 & 255], 24) ^ $shift(this$static, T0[this$static.C0 >> 16 & 255], 16) ^ $shift(this$static, T0[this$static.C1 >> 24 & 255], 8) ^ KW[r][2];
    r3 = T0[this$static.C3 & 255] ^ $shift(this$static, T0[this$static.C0 >> 8 & 255], 24) ^ $shift(this$static, T0[this$static.C1 >> 16 & 255], 16) ^ $shift(this$static, T0[this$static.C2 >> 24 & 255], 8) ^ KW[r++][3];
    this$static.C0 = T0[r0 & 255] ^ $shift(this$static, T0[r1 >> 8 & 255], 24) ^ $shift(this$static, T0[r2 >> 16 & 255], 16) ^ $shift(this$static, T0[r3 >> 24 & 255], 8) ^ KW[r][0];
    this$static.C1 = T0[r1 & 255] ^ $shift(this$static, T0[r2 >> 8 & 255], 24) ^ $shift(this$static, T0[r3 >> 16 & 255], 16) ^ $shift(this$static, T0[r0 >> 24 & 255], 8) ^ KW[r][1];
    this$static.C2 = T0[r2 & 255] ^ $shift(this$static, T0[r3 >> 8 & 255], 24) ^ $shift(this$static, T0[r0 >> 16 & 255], 16) ^ $shift(this$static, T0[r1 >> 24 & 255], 8) ^ KW[r][2];
    this$static.C3 = T0[r3 & 255] ^ $shift(this$static, T0[r0 >> 8 & 255], 24) ^ $shift(this$static, T0[r1 >> 16 & 255], 16) ^ $shift(this$static, T0[r2 >> 24 & 255], 8) ^ KW[r++][3];
  }
  r0 = T0[this$static.C0 & 255] ^ $shift(this$static, T0[this$static.C1 >> 8 & 255], 24) ^ $shift(this$static, T0[this$static.C2 >> 16 & 255], 16) ^ $shift(this$static, T0[this$static.C3 >> 24 & 255], 8) ^ KW[r][0];
  r1 = T0[this$static.C1 & 255] ^ $shift(this$static, T0[this$static.C2 >> 8 & 255], 24) ^ $shift(this$static, T0[this$static.C3 >> 16 & 255], 16) ^ $shift(this$static, T0[this$static.C0 >> 24 & 255], 8) ^ KW[r][1];
  r2 = T0[this$static.C2 & 255] ^ $shift(this$static, T0[this$static.C3 >> 8 & 255], 24) ^ $shift(this$static, T0[this$static.C0 >> 16 & 255], 16) ^ $shift(this$static, T0[this$static.C1 >> 24 & 255], 8) ^ KW[r][2];
  r3 = T0[this$static.C3 & 255] ^ $shift(this$static, T0[this$static.C0 >> 8 & 255], 24) ^ $shift(this$static, T0[this$static.C1 >> 16 & 255], 16) ^ $shift(this$static, T0[this$static.C2 >> 24 & 255], 8) ^ KW[r++][3];
  this$static.C0 = S[r0 & 255] & 255 ^ (S[r1 >> 8 & 255] & 255) << 8 ^ (S[r2 >> 16 & 255] & 255) << 16 ^ S[r3 >> 24 & 255] << 24 ^ KW[r][0];
  this$static.C1 = S[r1 & 255] & 255 ^ (S[r2 >> 8 & 255] & 255) << 8 ^ (S[r3 >> 16 & 255] & 255) << 16 ^ S[r0 >> 24 & 255] << 24 ^ KW[r][1];
  this$static.C2 = S[r2 & 255] & 255 ^ (S[r3 >> 8 & 255] & 255) << 8 ^ (S[r0 >> 16 & 255] & 255) << 16 ^ S[r1 >> 24 & 255] << 24 ^ KW[r][2];
  this$static.C3 = S[r3 & 255] & 255 ^ (S[r0 >> 8 & 255] & 255) << 8 ^ (S[r1 >> 16 & 255] & 255) << 16 ^ S[r2 >> 24 & 255] << 24 ^ KW[r][3];
}

function $generateWorkingKey(this$static, key, forEncryption){
  var KC, W, i, j, k, t, temp;
  KC = round_int(key.length_0 / 4);
  if (KC != 4 && KC != 6 && KC != 8 || KC * 4 != key.length_0) {
    throw $IllegalArgumentException(new IllegalArgumentException(), 'Key length not 128/192/256 bits.');
  }
  this$static.ROUNDS = KC + 6;
  W = initDims_0('[[I', [0, 19], [7, (-1)], [this$static.ROUNDS + 1, 4], 0);
  t = 0;
  i = 0;
  while (i < key.length_0) {
    W[t >> 2][t & 3] = key[i] & 255 | (key[i + 1] & 255) << 8 | (key[i + 2] & 255) << 16 | key[i + 3] << 24;
    i += 4;
    t++;
  }
  k = this$static.ROUNDS + 1 << 2;
  for (i = KC; i < k; i++) {
    temp = W[i - 1 >> 2][i - 1 & 3];
    if (i % KC == 0) {
      temp = $subWord(this$static, $shift(this$static, temp, 8)) ^ rcon[round_int(i / KC) - 1];
    }
     else if (KC > 6 && i % KC == 4) {
      temp = $subWord(this$static, temp);
    }
    W[i >> 2][i & 3] = W[i - KC >> 2][i - KC & 3] ^ temp;
  }
  if (!forEncryption) {
    for (j = 1; j < this$static.ROUNDS; j++) {
      for (i = 0; i < 4; i++) {
        W[j][i] = $inv_mcol(this$static, W[j][i]);
      }
    }
  }
  return W;
}

function $inv_mcol(this$static, x){
  var f2, f4, f8, f9;
  f2 = $FFmulX(this$static, x);
  f4 = $FFmulX(this$static, f2);
  f8 = $FFmulX(this$static, f4);
  f9 = x ^ f8;
  return f2 ^ f4 ^ f8 ^ $shift(this$static, f2 ^ f9, 8) ^ $shift(this$static, f4 ^ f9, 16) ^ $shift(this$static, f9, 24);
}

function $packBlock(this$static, bytes, off){
  var index;
  index = off;
  bytes[index++] = narrow_byte(this$static.C0);
  bytes[index++] = narrow_byte(this$static.C0 >> 8);
  bytes[index++] = narrow_byte(this$static.C0 >> 16);
  bytes[index++] = narrow_byte(this$static.C0 >> 24);
  bytes[index++] = narrow_byte(this$static.C1);
  bytes[index++] = narrow_byte(this$static.C1 >> 8);
  bytes[index++] = narrow_byte(this$static.C1 >> 16);
  bytes[index++] = narrow_byte(this$static.C1 >> 24);
  bytes[index++] = narrow_byte(this$static.C2);
  bytes[index++] = narrow_byte(this$static.C2 >> 8);
  bytes[index++] = narrow_byte(this$static.C2 >> 16);
  bytes[index++] = narrow_byte(this$static.C2 >> 24);
  bytes[index++] = narrow_byte(this$static.C3);
  bytes[index++] = narrow_byte(this$static.C3 >> 8);
  bytes[index++] = narrow_byte(this$static.C3 >> 16);
  bytes[index++] = narrow_byte(this$static.C3 >> 24);
}

function $shift(this$static, r, shift){
  return r >>> shift | r << -shift;
}

function $subWord(this$static, x){
  return S[x & 255] & 255 | (S[x >> 8 & 255] & 255) << 8 | (S[x >> 16 & 255] & 255) << 16 | S[x >> 24 & 255] << 24;
}

function $unpackBlock(this$static, bytes, off){
  var index;
  index = off;
  this$static.C0 = bytes[index++] & 255;
  this$static.C0 |= (bytes[index++] & 255) << 8;
  this$static.C0 |= (bytes[index++] & 255) << 16;
  this$static.C0 |= bytes[index++] << 24;
  this$static.C1 = bytes[index++] & 255;
  this$static.C1 |= (bytes[index++] & 255) << 8;
  this$static.C1 |= (bytes[index++] & 255) << 16;
  this$static.C1 |= bytes[index++] << 24;
  this$static.C2 = bytes[index++] & 255;
  this$static.C2 |= (bytes[index++] & 255) << 8;
  this$static.C2 |= (bytes[index++] & 255) << 16;
  this$static.C2 |= bytes[index++] << 24;
  this$static.C3 = bytes[index++] & 255;
  this$static.C3 |= (bytes[index++] & 255) << 8;
  this$static.C3 |= (bytes[index++] & 255) << 16;
  this$static.C3 |= bytes[index++] << 24;
}

function getBlockSize(){
  return 16;
}

function init_0(forEncryption, params){
  if (instanceOf(params, 5)) {
    this.WorkingKey = $generateWorkingKey(this, dynamicCast(params, 5).getKey(), forEncryption);
    this.forEncryption = forEncryption;
    return;
  }
  throw $IllegalArgumentException(new IllegalArgumentException(), 'invalid parameter passed to AES init - ');
}

function processBlock(in_$, inOff, out, outOff){
  if (this.WorkingKey === null) {
    throw $IllegalStateException(new IllegalStateException(), 'AES engine not initialised');
  }
  if (inOff + 16 > in_$.length_0) {
    throw $DataLengthException(new DataLengthException(), 'input buffer too short');
  }
  if (outOff + 16 > out.length_0) {
    throw $DataLengthException(new DataLengthException(), 'output buffer too short');
  }
  if (this.forEncryption) {
    $unpackBlock(this, in_$, inOff);
    $encryptBlock(this, this.WorkingKey);
    $packBlock(this, out, outOff);
  }
   else {
    $unpackBlock(this, in_$, inOff);
    $decryptBlock(this, this.WorkingKey);
    $packBlock(this, out, outOff);
  }
  return 16;
}

function reset(){
}

function AESEngine(){
}

_ = AESEngine.prototype = new Object_0();
_.getBlockSize = getBlockSize;
_.init = init_0;
_.processBlock = processBlock;
_.reset = reset;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'AESEngine';
_.typeId$ = 0;
_.C0 = 0;
_.C1 = 0;
_.C2 = 0;
_.C3 = 0;
_.ROUNDS = 0;
_.WorkingKey = null;
_.forEncryption = false;
var S, Si, T0, Tinv0, rcon;
function $clinit_32(){
  $clinit_32 = nullMethod;
  KP = initValues('[I', 19, (-1), [608135816, (-2052912941), 320440878, 57701188, (-1542899678), 698298832, 137296536, (-330404727), 1160258022, 953160567, (-1101764913), 887688300, (-1062458953), (-914599715), 1065670069, (-1253635817), (-1843997223), (-1988494565)]);
  KS0 = initValues('[I', 19, (-1), [(-785314906), (-1730169428), 805139163, (-803545161), (-1193168915), 1780907670, (-1166241723), (-248741991), 614570311, (-1282315017), 134345442, (-2054226922), 1667834072, 1901547113, (-1537671517), (-191677058), 227898511, 1921955416, 1904987480, (-2112533778), 2069144605, (-1034266187), (-1674521287), 720527379, (-976113629), 677414384, (-901678824), (-1193592593), (-1904616272), 1614419982, 1822297739, (-1340175810), (-686458943), (-1120842969), 2024746970, 1432378464, (-430627341), (-1437226092), 1464375394, 1676153920, 1439316330, 715854006, (-1261675468), 289532110, (-1588296017), 2087905683, (-1276242927), 1668267050, 732546397, 1947742710, (-832815594), (-1685613794), (-1344882125), 1814351708, 2050118529, 680887927, 999245976, 1800124847, (-994056165), 1713906067, 1641548236, (-81679983), 1216130144, 1575780402, (-276538019), (-377129551), (-601480446), (-345695352), 596196993, (-745100091), 258830323, (-2081144263), 772490370, (-1534844924), 1774776394, (-1642095778), 566650946, (-152474470), 1728879713, (-1412200208), 1783734482, (-665571480), (-1777359064), (-1420741725), 1861159788, 326777828, (-1170476976), 2130389656, (-1578015459), 967770486, 1724537150, (-2109534584), (-1930525159), 1164943284, 2105845187, 998989502, (-529566248), (-2050940813), 1075463327, 1455516326, 1322494562, 910128902, 469688178, 1117454909, 936433444, (-804646328), (-619713837), 1240580251, 122909385, (-2137449605), 634681816, (-152510729), (-469872614), (-1233564613), (-1754472259), 79693498, (-1045868618), 1084186820, 1583128258, 426386531, 1761308591, 1047286709, 322548459, 995290223, 1845252383, (-1691314900), (-863943356), (-1352745719), (-1092366332), (-567063811), 1712269319, 422464435, (-1060394921), 1170764815, (-771006663), (-1177289765), 1434042557, 442511882, (-694091578), 1076654713, 1738483198, (-81812532), (-1901729288), (-617471240), 1014306527, (-43947243), 793779912, (-1392160085), 842905082, (-48003232), 1395751752, 1040244610, (-1638115397), (-898659168), 445077038, (-552113701), (-717051658), 679411651, (-1402522938), (-1940957837), 1767581616, (-1144366904), (-503340195), (-1192226400), 284835224, (-48135240), 1258075500, 768725851, (-1705778055), (-1225243291), (-762426948), 1274779536, (-505548070), (-1530167757), 1660621633, (-823867672), (-283063590), 913787905, (-797008130), 737222580, (-1780753843), (-1366257256), (-357724559), 1804850592, (-795946544), (-1345903136), (-1908647121), (-1904896841), (-1879645445), (-233690268), (-2004305902), (-1878134756), 1336762016, 1754252060, (-774901359), (-1280786003), 791618072, (-1106372745), (-361419266), (-1962795103), (-442446833), (-1250986776), 413987798, (-829824359), (-1264037920), (-49028937), 2093235073, (-760370983), 375366246, (-2137688315), (-1815317740), 555357303, (-424861595), 2008414854, (-950779147), (-73583153), (-338841844), 2067696032, (-700376109), (-1373733303), 2428461, 544322398, 577241275, 1471733935, 610547355, (-267798242), 1432588573, 1507829418, 2025931657, (-648391809), 545086370, 48609733, (-2094660746), 1653985193, 298326376, 1316178497, (-1287180854), 2064951626, 458293330, (-1705826027), (-703637697), (-1130641692), 727753846, (-2115603456), 146436021, 1461446943, (-224990101), 705550613, (-1235000031), (-407242314), (-13368018), (-981117340), 1404054877, (-1449160799), 146425753, 1854211946]);
  KS1 = initValues('[I', 19, (-1), [1266315497, (-1246549692), (-613086930), (-1004984797), (-1385257296), 1235738493, (-1662099272), (-1880247706), (-324367247), 1771706367, 1449415276, (-1028546847), 422970021, 1963543593, (-1604775104), (-468174274), 1062508698, 1531092325, 1804592342, (-1711849514), (-1580033017), (-269995787), 1294809318, (-265986623), 1289560198, (-2072974554), 1669523910, 35572830, 157838143, 1052438473, 1016535060, 1802137761, 1753167236, 1386275462, (-1214491899), (-1437595849), 1040679964, 2145300060, (-1904392980), 1461121720, (-1338320329), (-263189491), (-266592508), 33600511, (-1374882534), 1018524850, 629373528, (-603381315), (-779021319), 2091462646, (-1808644237), 586499841, 988145025, 935516892, (-927631820), (-1695294041), (-1455136442), 265290510, (-322386114), (-1535828415), (-499593831), 1005194799, 847297441, 406762289, 1314163512, 1332590856, 1866599683, (-167115585), 750260880, 613907577, 1450815602, (-1129346641), (-560302305), (-644675568), (-1282691566), (-590397650), 1427272223, 778793252, 1343938022, (-1618686585), 2052605720, 1946737175, (-1130390852), (-380928628), (-327488454), (-612033030), 1661551462, (-1000029230), (-283371449), 840292616, (-582796489), 616741398, 312560963, 711312465, 1351876610, 322626781, 1910503582, 271666773, (-2119403562), 1594956187, 70604529, (-677132437), 1007753275, 1495573769, (-225450259), (-1745748998), (-1631928532), 504708206, (-2031925904), (-353800271), (-2045878774), 1514023603, 1998579484, 1312622330, 694541497, (-1712906993), (-2143385130), 1382467621, 776784248, (-1676627094), (-971698502), (-1797068168), (-1510196141), 503983604, (-218673497), 907881277, 423175695, 432175456, 1378068232, (-149744970), (-340918674), (-356311194), (-474200683), (-1501837181), (-1317062703), 26017576, (-1020076561), (-1100195163), 1700274565, 1756076034, (-288447217), (-617638597), 720338349, 1533947780, 354530856, 688349552, (-321042571), 1637815568, 332179504, (-345916010), 53804574, (-1442618417), (-1250730864), 1282449977, (-711025141), (-877994476), (-288586052), 1617046695, (-1666491221), (-1292663698), 1686838959, 431878346, (-1608291911), 1700445008, 1080580658, 1009431731, 832498133, (-1071531785), (-1688990951), (-2023776103), (-1778935426), 1648197032, (-130578278), (-1746719369), 300782431, 375919233, 238389289, (-941219882), (-1763778655), 2019080857, 1475708069, 455242339, (-1685863425), 448939670, (-843904277), 1395535956, (-1881585436), 1841049896, 1491858159, 885456874, (-30872223), (-293847949), 1565136089, (-396052509), 1108368660, 540939232, 1173283510, (-1549095958), (-613658859), (-87339056), (-951913406), (-278217803), 1699691293, 1103962373, (-669091426), (-2038084153), (-464828566), 1031889488, (-815619598), 1535977030, (-58162272), (-1043876189), 2132092099, 1774941330, 1199868427, 1452454533, 157007616, (-1390851939), 342012276, 595725824, 1480756522, 206960106, 497939518, 591360097, 863170706, (-1919713727), (-698356495), 1814182875, 2094937945, (-873565088), 1082520231, (-831049106), (-1509457788), 435703966, (-386934699), 1641649973, (-1452693590), (-989067582), 1510255612, (-2146710820), (-1639679442), (-1018874748), (-36346107), 236887753, (-613164077), 274041037, 1734335097, (-479771840), (-976997275), 1899903192, 1026095262, (-244449504), 356393447, (-1884275382), (-421290197), (-612127241)]);
  KS2 = initValues('[I', 19, (-1), [(-381855128), (-1803468553), (-162781668), (-1805047500), 1091903735, 1979897079, (-1124832466), (-727580568), (-737663887), 857797738, 1136121015, 1342202287, 507115054, (-1759230650), 337727348, (-1081374656), 1301675037, (-1766485585), 1895095763, 1721773893, (-1078195732), 62756741, 2142006736, 835421444, (-1762973773), 1442658625, (-635090970), (-1412822374), 676362277, 1392781812, 170690266, (-373920261), 1759253602, (-683120384), 1745797284, 664899054, 1329594018, (-393761396), (-1249058810), 2062866102, (-1429332356), (-751345684), (-830954599), 1080764994, 553557557, (-638351943), (-298199125), 991055499, 499776247, 1265440854, 648242737, (-354183246), 980351604, (-581221582), 1749149687, (-898096901), (-83167922), (-654396521), 1161844396, (-1169648345), 1431517754, 545492359, (-26498633), (-795437749), 1437099964, (-1592419752), (-861329053), (-1713251533), (-1507177898), 1060185593, 1593081372, (-1876348548), (-34019326), 69676912, (-2135222948), 86519011, (-1782508216), (-456757982), 1220612927, (-955283748), 133810670, 1090789135, 1078426020, 1569222167, 845107691, (-711212847), (-222510705), 1091646820, 628848692, 1613405280, (-537335645), 526609435, 236106946, 48312990, (-1352249391), (-892239595), 1797494240, 859738849, 992217954, (-289490654), (-2051890674), (-424014439), (-562951028), 765654824, (-804095931), (-1783130883), 1685915746, (-405998096), 1414112111, (-2021832454), (-1013056217), (-214004450), 172450625, (-1724973196), 980381355, (-185008841), (-1475158944), (-1578377736), (-1726226100), (-613520627), (-964995824), 1835478071, 660984891, (-590288892), (-248967737), (-872349789), (-1254551662), 1762651403, 1719377915, (-824476260), (-1601057013), (-652910941), (-1156370552), 1364962596, 2073328063, 1983633131, 926494387, (-871278215), (-2144935273), (-198299347), 1749200295, (-966120645), 309677260, 2016342300, 1779581495, (-1215147545), 111262694, 1274766160, 443224088, 298511866, 1025883608, (-488520759), 1145181785, 168956806, (-653464466), (-710153686), 1689216846, (-628709281), (-1094719096), 1692713982, (-1648590761), (-252198778), 1618508792, 1610833997, (-771914938), (-164094032), 2001055236, (-684262196), (-2092799181), (-266425487), (-1333771897), 1006657119, 2006996926, (-1108824540), 1430667929, (-1084739999), 1314452623, (-220332638), (-193663176), (-2021016126), 1399257539, (-927756684), (-1267338667), 1190975929, 2062231137, (-1960976508), (-2073424263), (-1856006686), 1181637006, 548689776, (-1932175983), (-922558900), (-1190417183), (-1149106736), 296247880, 1970579870, (-1216407114), (-525738999), 1714227617, (-1003338189), (-396747006), 166772364, 1251581989, 493813264, 448347421, 195405023, (-1584991729), 677966185, (-591930749), 1463355134, (-1578971493), 1338867538, 1343315457, (-1492745222), (-1610435132), 233230375, (-1694987225), 2000651841, (-1017099258), 1638401717, (-266896856), (-1057650976), 6314154, 819756386, 300326615, 590932579, 1405279636, (-1027467724), (-1144263082), (-1866680610), (-335774303), (-833020554), 1862657033, 1266418056, 963775037, 2089974820, (-2031914401), 1917689273, 448879540, (-744572676), (-313240200), 150775221, (-667058989), 1303187396, 508620638, (-1318983944), (-1568336679), 1817252668, 1876281319, 1457606340, 908771278, (-574175177), (-677760460), (-1838972398), 1729034894, 1080033504]);
  KS3 = initValues('[I', 19, (-1), [976866871, (-738527793), (-1413318857), 1522871579, 1555064734, 1336096578, (-746444992), (-1715692610), (-720269667), (-1089506539), (-701686658), (-956251013), (-1215554709), 564236357, (-1301368386), 1781952180, 1464380207, (-1131123079), (-962365742), 1699332808, 1393555694, 1183702653, (-713881059), 1288719814, 691649499, (-1447410096), (-1399511320), (-1101077756), (-1577396752), 1781354906, 1676643554, (-1702433246), (-1064713544), 1126444790, (-1524759638), (-1661808476), (-2084544070), (-1679201715), (-1880812208), (-1167828010), 673620729, (-1489356063), 1269405062, (-279616791), (-953159725), (-145557542), 1057255273, 2012875353, (-2132498155), (-2018474495), (-1693849939), 993977747, (-376373926), (-1640704105), 753973209, 36408145, (-1764381638), 25011837, (-774947114), 2088578344, 530523599, (-1376601957), 1524020338, 1518925132, (-534139791), (-535190042), 1202760957, (-309069157), (-388774771), 674977740, (-120232407), 2031300136, 2019492241, (-311074731), (-141160892), (-472686964), 352677332, (-1997247046), 60907813, 90501309, (-1007968747), 1016092578, (-1759044884), (-1455814870), 457141659, 509813237, (-174299397), 652014361, 1966332200, (-1319764491), 55981186, (-1967506245), 676427537, (-1039476232), (-1412673177), (-861040033), 1307055953, 942726286, 933058658, (-1826555503), (-361066302), (-79791154), 1361170020, 2001714738, (-1464409218), (-1020707514), 1222529897, 1679025792, (-1565652976), (-580013532), 1770335741, 151462246, (-1281735158), 1682292957, 1483529935, 471910574, 1539241949, 458788160, (-858652289), 1807016891, (-576558466), 978976581, 1043663428, (-1129001515), 1927990952, (-94075717), (-1922690386), (-1086558393), (-761535389), 1412390302, (-1362987237), (-162634896), 1947078029, (-413461673), (-126740879), (-1353482915), 1077988104, 1320477388, 886195818, 18198404, (-508558296), (-1785185763), 112762804, (-831610808), 1866414978, 891333506, 18488651, 661792760, 1628790961, (-409780260), (-1153795797), 876946877, (-1601685023), 1372485963, 791857591, (-1608533303), (-534984578), (-1127755274), (-822013501), (-1578587449), 445679433, (-732971622), (-790962485), (-720709064), 54117162, (-963561881), (-1913048708), (-525259953), (-140617289), 1140177722, (-220915201), 668550556, (-1080614356), 367459370, 261225585, (-1684794075), (-85617823), (-826893077), (-1029151655), 314222801, (-1228863650), (-486184436), 282218597, (-888953790), (-521376242), 379116347, 1285071038, 846784868, (-1625320142), (-523005217), (-744475605), (-1989021154), 453669953, 1268987020, (-977374944), (-1015663912), (-550133875), (-1684459730), (-435458233), 266596637, (-447948204), 517658769, (-832407089), (-851542417), 370717030, (-47440635), (-2070949179), (-151313767), (-182193321), (-1506642397), (-1817692879), 1456262402, (-1393524382), 1517677493, 1846949527, (-1999473716), (-560569710), (-2118563376), 1280348187, 1908823572, (-423180355), 846861322, 1172426758, (-1007518822), (-911584259), 1655181056, (-1155153950), 901632758, 1897031941, (-1308360158), (-1228157060), (-847864789), 1393639104, 373351379, 950779232, 625454576, (-1170726756), (-146354570), 2007998917, 544563296, (-2050228658), (-1964470824), 2058025392, 1291430526, 424198748, 50039436, 29584100, (-689184263), (-1865090967), (-1503863136), 1057563949, (-1039604065), (-1219600078), (-831004069), 1469046755, 985887462]);
}

function $Bits32ToBytes(this$static, in_$, b, offset){
  b[offset + 3] = narrow_byte(in_$);
  b[offset + 2] = narrow_byte(in_$ >> 8);
  b[offset + 1] = narrow_byte(in_$ >> 16);
  b[offset] = narrow_byte(in_$ >> 24);
}

function $BlowfishEngine(this$static){
  $clinit_32();
  this$static.S0 = initDims_0('[I', [19], [(-1)], [256], 0);
  this$static.S1 = initDims_0('[I', [19], [(-1)], [256], 0);
  this$static.S2 = initDims_0('[I', [19], [(-1)], [256], 0);
  this$static.S3 = initDims_0('[I', [19], [(-1)], [256], 0);
  this$static.P = initDims_0('[I', [19], [(-1)], [18], 0);
  return this$static;
}

function $BytesTo32bits(this$static, b, i){
  return (b[i] & 255) << 24 | (b[i + 1] & 255) << 16 | (b[i + 2] & 255) << 8 | b[i + 3] & 255;
}

function $F(this$static, x){
  return (this$static.S0[x >>> 24] + this$static.S1[x >>> 16 & 255] ^ this$static.S2[x >>> 8 & 255]) + this$static.S3[x & 255];
}

function $decryptBlock_0(this$static, src, srcIndex, dst, dstIndex){
  var i, xl, xr;
  xl = $BytesTo32bits(this$static, src, srcIndex);
  xr = $BytesTo32bits(this$static, src, srcIndex + 4);
  xl ^= this$static.P[17];
  for (i = 16; i > 0; i -= 2) {
    xr ^= $F(this$static, xl) ^ this$static.P[i];
    xl ^= $F(this$static, xr) ^ this$static.P[i - 1];
  }
  xr ^= this$static.P[0];
  $Bits32ToBytes(this$static, xr, dst, dstIndex);
  $Bits32ToBytes(this$static, xl, dst, dstIndex + 4);
}

function $encryptBlock_0(this$static, src, srcIndex, dst, dstIndex){
  var i, xl, xr;
  xl = $BytesTo32bits(this$static, src, srcIndex);
  xr = $BytesTo32bits(this$static, src, srcIndex + 4);
  xl ^= this$static.P[0];
  for (i = 1; i < 16; i += 2) {
    xr ^= $F(this$static, xl) ^ this$static.P[i];
    xl ^= $F(this$static, xr) ^ this$static.P[i + 1];
  }
  xr ^= this$static.P[17];
  $Bits32ToBytes(this$static, xr, dst, dstIndex);
  $Bits32ToBytes(this$static, xl, dst, dstIndex + 4);
}

function $processTable(this$static, xl, xr, table){
  var i, s, size;
  size = table.length_0;
  for (s = 0; s < size; s += 2) {
    xl ^= this$static.P[0];
    for (i = 1; i < 16; i += 2) {
      xr ^= $F(this$static, xl) ^ this$static.P[i];
      xl ^= $F(this$static, xr) ^ this$static.P[i + 1];
    }
    xr ^= this$static.P[17];
    table[s] = xr;
    table[s + 1] = xl;
    xr = xl;
    xl = table[s];
  }
}

function $setKey(this$static, key){
  var data, i, j, keyIndex, keyLength;
  arraycopy_0(KS0, 0, this$static.S0, 0, 256);
  arraycopy_0(KS1, 0, this$static.S1, 0, 256);
  arraycopy_0(KS2, 0, this$static.S2, 0, 256);
  arraycopy_0(KS3, 0, this$static.S3, 0, 256);
  arraycopy_0(KP, 0, this$static.P, 0, 18);
  keyLength = key.length_0;
  keyIndex = 0;
  for (i = 0; i < 18; i++) {
    data = 0;
    for (j = 0; j < 4; j++) {
      data = data << 8 | key[keyIndex++] & 255;
      if (keyIndex >= keyLength) {
        keyIndex = 0;
      }
    }
    this$static.P[i] ^= data;
  }
  $processTable(this$static, 0, 0, this$static.P);
  $processTable(this$static, this$static.P[16], this$static.P[17], this$static.S0);
  $processTable(this$static, this$static.S0[254], this$static.S0[255], this$static.S1);
  $processTable(this$static, this$static.S1[254], this$static.S1[255], this$static.S2);
  $processTable(this$static, this$static.S2[254], this$static.S2[255], this$static.S3);
}

function getBlockSize_0(){
  return 8;
}

function init_1(encrypting, params){
  if (instanceOf(params, 5)) {
    this.encrypting = encrypting;
    this.workingKey = dynamicCast(params, 5).getKey();
    $setKey(this, this.workingKey);
    return;
  }
  throw $IllegalArgumentException(new IllegalArgumentException(), 'invalid parameter passed to Blowfish init - ');
}

function processBlock_0(in_$, inOff, out, outOff){
  if (this.workingKey === null) {
    throw $IllegalStateException(new IllegalStateException(), 'Blowfish not initialised');
  }
  if (inOff + 8 > in_$.length_0) {
    throw $DataLengthException(new DataLengthException(), 'input buffer too short');
  }
  if (outOff + 8 > out.length_0) {
    throw $DataLengthException(new DataLengthException(), 'output buffer too short');
  }
  if (this.encrypting) {
    $encryptBlock_0(this, in_$, inOff, out, outOff);
  }
   else {
    $decryptBlock_0(this, in_$, inOff, out, outOff);
  }
  return 8;
}

function reset_0(){
}

function BlowfishEngine(){
}

_ = BlowfishEngine.prototype = new Object_0();
_.getBlockSize = getBlockSize_0;
_.init = init_1;
_.processBlock = processBlock_0;
_.reset = reset_0;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'BlowfishEngine';
_.typeId$ = 0;
_.P = null;
_.S0 = null;
_.S1 = null;
_.S2 = null;
_.S3 = null;
_.encrypting = false;
_.workingKey = null;
var KP, KS0, KS1, KS2, KS3;
function $clinit_33(){
  $clinit_33 = nullMethod;
  S1 = initValues('[I', 19, (-1), [821772500, (-1616838901), 1810681135, 1059425402, 505495343, (-1677701677), 1610868032, (-811611831), (-1076580569), (-2000962123), (-503103344), (-1731160459), 1852023008, 365126098, (-1025022435), 584384398, 677919599, (-1065365415), (-14452280), 2002735330, 1136869587, (-550533546), (-2005097446), (-1563247315), (-1580605226), 879511577, 1639411079, 575934255, 717107937, (-1437329813), 576097850, (-1563213360), 1725645000, (-1484506833), 5111599, 767152862, (-1751892052), 1251459544, 1383482551, (-1242286169), (-1205028113), (-682503847), 1878520045, 1510570527, (-2105841456), (-1863518930), 582008916, (-1131521739), 1265446783, 1354458274, (-765048560), (-1092255443), (-1221385584), (-382003809), (-1265703919), 1275016285, (-45759936), (-1389258945), (-990457810), 1442611557, (-709768531), (-1582551634), (-1563117715), (-1046803376), (-2011021070), 208555832, (-1528512553), 1331405426, 1447828783, (-979610855), (-1186340012), (-1337562626), (-1313428598), (-955033379), 1669711173, 286233437, 1465092821, 1782121619, (-432195616), 710211251, 980974943, 1651941557, 430374111, 2051154026, 704238805, (-165996399), (-1150146722), (-1437564569), 948965521, (-961214997), (-2067281012), 718756367, (-2025188313), (-1563323541), 718440111, (-1437150575), (-678870176), 1113355533, (-1816945114), 410092745, 1811985197, 1944238868, (-1598112708), 1415722873, 1682284203, 1060277122, 1998114690, 1503841958, 82706478, (-1979811610), 1068173648, 845149890, (-2127020283), 1768146376, 1993038550, (-728140599), (-904393265), 940016341, (-939893514), (-1966926575), 904371731, 1205506512, (-200306554), (-1478344290), 825647681, 85914773, (-1437123836), 1249926541, 1417871568, 3287612, (-1083912737), (-1168660850), 1975924523, 1353700161, (-1480510859), (-1856369675), 1800716203, 722146342, (-1421030953), 1151126914, (-134483355), (-1417296397), 458611604, (-1428888796), (-811287233), 770352098, (-1642050302), (-927128148), (-354462285), (-708993384), (-485346894), 718646636, (-1790760482), (-1380039384), (-663679127), (-1437480689), (-1434948618), 575749918, (-1437489253), 718488780, 2069512688, (-746783827), 453416197, 1106044049, (-1262275866), 52586708, (-916452660), (-835158419), (-1083461268), 1785789304, 218356169, (-723568162), (-535796774), 1194783844, 1523787992, (-1287140202), 1975193539, (-1739514885), 1341901877, (-1249128598), (-518059332), (-1077543350), (-1492456432), (-1405528310), 1057244207, 1636348243, (-533104082), 1462225785, (-1662303857), 481089165, 718503062, 24497053, (-962724087), (-950311440), (-639942440), (-334596231), 1195698900, (-1323552140), (-584791138), 2115785917, (-267303687), (-769388879), (-1770671107), (-1548994731), (-730060881), 1372086093, 1452307862, (-1514465818), 1476592880, (-905696015), 18495466, (-1916818725), 901398090, 891748256, (-1015329527), (-1137676583), (-1734007194), 1447622437, (-10594659), 216884176, 2086908623, 1879786977, (-706064143), (-2052511630), (-1356874329), (-735885200), (-1484321805), 758861177, 1121993112, 215018983, 642190776, (-125730484), 1196255959, 2081185372, (-786228903), 941322904, (-170724133), (-1417443757), 1848581667, (-2089706338), (-1114513338), (-1705622162), (-600236020), 550028657, (-1775511012), (-504981761), (-1321096440), 2093648313, 443148163, 46942275, (-1560820359), 1117713533, 1115362972, 1523183689, (-577827072), 1551984063]);
  S2 = initValues('[I', 19, (-1), [522195092, (-284448933), 1776537470, 960447360, (-27144326), (-289070982), 1435016340, 1929119313, (-1381503111), 1310552629, (-715496498), (-570149190), (-1715195665), 1594623892, 417127293, (-1579749389), (-1598738565), 1508390405, (-300568428), (-369108727), (-599523194), (-275495847), (-1165767501), (-524038661), (-774225535), 990456497, (-107482687), (-1511600261), 21106139, (-454561957), 631373633, (-511641594), 532942976, 396095098, (-746928471), (-27774812), (-1730245761), 2011709262, 2039648873, 620404603, (-518797221), (-1396440957), (-682609371), (-135634593), 1645490516, 223693667, 1567101217, (-932789415), 1029951347, (-824036160), (-724009337), 1550265121, 119497089, 972513919, 907948164, (-454338757), 1613718692, (-700789348), 465323573, (-1635712211), 654439692, (-1719371084), (-1595678855), (-1167264884), 277098644, 624404830, (-194023426), (-1577108705), 546110314, (-1891267468), (-639589849), 1321679412, (-58175639), 1045293279, (-284295032), 895050893, (-1975175028), 494945126, 1914543101, (-1517910853), (-400202957), (-2075229678), 311263384, (-19710028), (-836236575), 669096869, (-710491566), (-459844419), (-975809059), (-345608092), 2005142349, (-1581864959), (-2066012503), (-524982508), 569394103, (-439330720), 1425027204, 108000370, (-1558535853), (-623098027), (-1251844673), 1750473702, (-2083886188), 762237499, (-321977893), (-1496067910), (-1233109668), (-1351112951), 867476300, 964413654, 1591880597, 1594774276, (-2115145887), 552026980, (-1268903048), (-568826981), (-2011389662), (-1184422191), (-2142656536), 582474363, 1582640421, 1383256631, 2043843868, (-972191412), 1217180674, 463797851, (-1531928725), 480777679, (-1576259579), (-2005803165), (-1176621109), 214354409, 200212307, (-484358889), (-1269553099), (-1620891332), (-297670871), 1847405948, 1342460550, 510035443, (-214695482), 815934613, 833030224, 1620250387, 1945732119, (-1591306151), (-328967100), 1388869545, (-838913114), (-1607788735), 2092620194, 562037615, 1356438536, (-885045151), (-1033119899), 1688467115, (-2144065930), 631725691, (-454635012), 549916902, (-839862656), 394546491, 837744717, 2114462948, 751520235, (-2073412690), (-1879607160), (-295870218), 2063029875, 803036379, (-1592380991), 821456707, (-1275401132), 360699898, (-276465204), (-783098280), (-617611938), (-1892495847), 812317050, 49299192, (-1724802347), (-1035798001), (-1478235216), (-963753722), (-1193663732), (-2138951640), (-589368376), (-748703375), 143268808, (-1094662816), 1638124008, (-1129777843), (-953159686), 578956953, (-2100989772), (-656847223), (-1961085764), 807278310, 658237817, (-1325405530), 1641658566, 11683945, (-1207972289), 148645947, 1138423386, (-136210536), 1981396783, (-1893950556), (-595183712), 380097457, (-1614572617), (-1491898645), (-960707010), 441530178, (-278386500), 1375954390, 761952171, 891809099, (-2111843818), 157052462, (-611126533), 1592404427, 341349109, (-1856483457), 1417898363, 644327628, (-2061934520), (-1941197590), (-2093457196), 220455161, 1815641738, 182899273, (-1299947508), (-667585763), (-592329145), (-1404283158), 1052606899, 588164016, 1681439879, (-256527878), (-1889623373), (-65518014), 167996282, 1336969661, 1688053129, (-1555742370), 1543734051, 1046297529, 1138201970, 2121126012, 115334942, 1819067631, 1902159161, 1941945968, (-2088274427), 1159982321]);
  S3 = initValues('[I', 19, (-1), [(-1913667008), 637164959, (-342868545), (-401553145), 1197506559, 916448331, (-1944074684), (-1362179440), (-1095632449), (-285488406), (-389080752), 1373570990, (-1844541434), (-257096376), (-516125309), (-1838149419), 286293407, 124026297, (-1293687596), 1028597854, (-1179670496), (-86080800), (-1603852661), (-2106427090), 1430237888, 1218109995, (-722495596), 308166588, 570424558, (-2107958275), (-1839872531), 307733056, 1310360322, (-1159692289), 1384269543, (-1906895858), 863238079, (-1935703672), (-1493414168), (-914180699), (-1463804489), 1470087780, 1728663345, (-222478497), 1090516929, 532123132, (-1905536319), 1132193179, (-1716503105), (-1243888053), 1670234342, 1434557849, (-1583888356), 1241591150, (-980923864), (-859607183), (-1203518957), 1812415473, (-2096527044), 267246943, 796911696, (-675250306), 38830015, 1526438404, (-1488465200), 374413614, (-1351565506), 1489179520, 1603809326, 1920779204, 168801282, 260042626, (-1936261715), 1563175598, (-1897293239), 1356499128, (-2077756256), 514611088, 2037363785, (-2108498923), (-272794213), (-1502455427), (-1381482280), 1173701892, (-94538749), (-398540027), 1334932762, (-1839830590), 602925377, (-1459359442), 1613172210, 41346230, (-1795332748), (-1837529678), (-2106139701), 41386358, (-122711667), 1313404830, (-1889440289), (-492993522), (-2077262461), 873260488, (-1766082942), (-1816874680), (-282051413), (-1739608280), 2006953883, (-1831053811), 575479328, (-2076726648), 2099895446, 660001756, (-1953465106), (-1256205760), (-406815517), (-446253919), (-1008115362), 1022894237, 1620365795, (-845372607), 1551255054, 15374395, (-724141951), (-45656276), (-143856167), (-1113054564), 310226346, 1133119310, 530038928, 136043402, (-1818198338), (-1187460587), (-1750057729), 1036173560, (-1927630100), 1681395281, 1758231547, (-653318264), 306774401, 1575354324, (-578881430), 1990386196, (-1180433560), (-1839360625), 1262092282, (-1170624791), (-1526738165), (-84438213), 1833535011, 423410938, 660763973, (-2107837318), 1639812000, (-786545967), (-827521804), 310289298, 272797111, (-2106414734), (-1838103384), 310240523, 677093832, 1013118031, 901835429, (-402271695), 1116285435, (-1258496126), 1337354835, 243122523, 520626091, 277223598, (-50526099), (-100718455), 1766575121, 594173102, 316590669, 742362309, (-758108674), (-118531946), (-456174886), (-1793762457), 1229605004, (-1179211764), 1552908988, (-1982633147), 979407927, (-335492695), 1148277331, 176638793, (-680281024), 2083809052, 40992502, 1340822838, (-1563414529), (-759209788), (-734067776), 1354035053, 122129617, 7215240, (-1562034347), (-1176054596), (-1576763370), (-1755891661), (-685736601), (-569405635), 1928887091, (-1412673741), 1988674909, 2063640240, (-1803878399), 1459647954, (-105150216), (-1992162914), 1113892351, (-2057108768), 1927010603, (-292086935), 1856122846, 1594404395, (-1350934163), (-439777433), (-819991598), 1643104450, (-240376463), (-863880766), 1730235576, (-1310358575), (-1210302878), 2131803598, (-116761544), 267404349, 1617849798, 1616132681, 1462223176, 736725533, (-1967909064), 551665188, (-1349068273), 1749386277, (-1719452699), 1611482493, 674206544, (-2093698206), (-652406496), 728599968, 1680547377, (-1674552832), 1388111496, 453204106, (-138743851), 1094905244, (-1540269039), (-2093859131), (-537967050), (-1590442751), (-372026596), (-298502269)]);
  S4 = initValues('[I', 19, (-1), [(-1649212384), 532081118, (-1480688657), (-764173672), 1246723035, 1689095255, (-2058288061), (-100528431), 2116582143, (-435177885), 157234593, 2045505824, (-49963709), 1687664561, (-211542173), 605965023, 672431967, 1336064205, (-918355904), 214114848, (-36500688), (-1062914225), 489488601, 605322005, (-296939238), 264917351, 1912574028, 756637694, 436560991, 202637054, 135989450, 85393697, (-2142043904), (-398565634), (-1399130888), 2145855233, (-759632289), 115294817, (-1147233398), 1922296357, (-830144545), (-177108991), 1037454084, (-1569774021), 2127856640, 1417604070, 1148013728, 1827919605, 642362335, (-1365194763), 909348033, 1346338451, (-747167647), 297154785, 1917849091, (-133254469), (-1411362770), (-326273058), 1469521537, (-514889914), (-919383040), 1763717519, 136166297, (-3996507), 1295325189, 2134727907, (-1496815930), 1566297257, (-622039062), (-1617793135), (-1622793681), 965822077, (-1514181234), 289653839, 1133871874, (-803123477), 35685304, 1068898316, 418943774, 672553190, 642281022, (-1948808592), 1954014401, (-1257840516), (-215152091), 2030668546, (-454378623), 672283427, 1776201016, 359975446, (-544793758), 555499703, (-1524982023), 1324923, 69110472, 152125443, (-1118182190), (-472820011), 1340634837, 798073664, 1434183902, 15393959, 216384236, 1303690150, (-413745665), (-583833172), (-333991883), 106373927, (-1716533072), 1455997841, 1801814300, 1578393881, 1854262133, (-1106788350), (-1036888713), (-1992297236), 1539295533, (-789824731), (-1216341321), (-1922221276), 549938159, (-1016683012), (-1674041216), 181285381, (-1429646198), (-324937785), 68876850, 488006234, 1728155692, (-1686799788), 836007927, (-1859735503), 919367643, (-955544762), (-639210936), 1457871481, 40520939, 1380155135, 797931188, 234455205, (-2039165469), (-304478997), 397000196, 739833055, (-1217101923), (-1423247436), (-272413408), 772369276, 390177364, (-441016267), 557662966, 740064294, 1640166671, 1699928825, (-759025160), 622006121, (-669614174), 68743880, 1742502, 219489963, 1664179233, 1577743084, 1236991741, 410585305, (-1928479354), 823226535, 1050371084, (-868347689), (-708127818), 212779912, (-147848735), 1819446015, 1911218849, 530248558, (-808726225), (-1042381801), (-1408778645), (-884694568), (-1952772266), 20547779, (-1312477238), (-1262603827), (-663214074), 312714466, 1870521650, 1493008054, (-803280640), 615382978, (-191295547), (-1760449851), 1932181, (-2098862126), 278426614, 6369430, (-1020422879), (-1381948929), 697336853, 2143000447, (-1348553765), 701099306, 1558357093, (-1489964244), (-794148888), (-1973632879), (-727831321), 216290473, (-703935098), 23009561, 1996984579, (-559924490), 2024298078, (-555526433), 569400510, (-1955208313), (-1278933423), (-1197095953), (-655444270), (-450642313), (-1038793431), 795471839, (-1343849733), (-193936206), (-203363493), (-691234698), 971261452, 534414648, 428311343, (-905940121), (-1450097416), 694888862, 1227866773, (-1838760277), (-1251512727), (-1680613926), (-545389265), (-618303460), 459166190, (-162323226), 1794958188, 51825668, (-2042355394), (-1210295856), 2036672799, (-858325693), 1099053433, (-1825845770), (-1235762355), 1323291266, 2061838604, 1018778475, (-2061623042), (-1741466242), 334295216, (-738217102), 1065731521, 183467730]);
  S5 = initValues('[I', 19, (-1), [2127105028, 745436345, (-1693554977), (-1506576111), (-1200979969), 500390133, 1155374404, 389092991, 150729210, (-403369524), (-771417344), 1935325696, 716645080, 946045387, (-1393155014), 1774124410, (-425531521), (-255385395), (-1001830378), (-856309376), 948246080, 363898952, (-427091765), 1286266623, 1598556673, 68334250, 630723836, 1104211938, 1312863373, 613332731, (-1917182722), 1101634306, 441780740, (-1165007413), 1917973735, (-1784342747), (-1056510761), (-1750755318), (-986072662), 1299840618, (-218892445), 1756332096, (-317940138), 297047435, (-504669560), (-2029394256), (-673156778), 1311375015, 1667687725, 47300608, (-995324411), (-1820854927), 201668394, 1468347890, 576830978, (-700276535), (-552361344), 1958042578, 1747032512, (-735975956), 1408974056, (-928125517), 682131401, 1033214337, 1545599232, (-29830247), 206503691, 103024618, (-1439739983), 1337551222, (-1865968379), (-1331124364), (-279600641), (-442719550), (-1498010329), (-429243805), (-547028961), 247794022, (-539142724), 702416469, (-1860275302), 397379957, 851939612, (-1980197784), 218229120, 1380406772, 62274761, 214451378, (-1124863830), (-2018756887), (-449154010), 28563499, 446592073, 1693330814, (-841240102), 29968656, (-1201094784), 220656637, (-1824330265), 77972100, 1667708854, 1358280214, (-230201629), (-1899350335), 325977563, (-17726575), (-74941897), (-689440812), (-939819575), 811859167, (-1225422370), (-332840486), 652502677, (-1219075047), (-162205755), (-796043081), 1217549313, (-1044722817), (-436251377), (-1240977335), 1538642152, (-2015941030), (-1419088159), 574252750, (-970198067), (-1643608583), 1758150215, 141295887, (-1575098336), (-779392546), (-201959561), (-100482058), 1082055363, (-877406896), 395511885, (-1328083270), 179534037, (-648938740), (-556279210), 1092926436, (-1798698154), 257381841, (-522066578), 1636087230, 1477059743, (-1795732544), (-483948402), (-1619307167), (-1008991616), 90732309, 1684827095, 1150307763, 1723134115, (-1057921910), 1769919919, 1240018934, 815675215, 750138730, (-2055174797), 1234303040, 1995484674, 138143821, 675421338, 1145607174, 1936608440, (-1056364272), (-1949737018), 2105974004, 323969391, 779555213, (-1290064927), (-1433357198), 1017501463, 2098600890, (-1666346992), (-1354355806), (-1612424750), 1171473753, (-638395885), (-607759225), (-203097778), 393037935, 159126506, 1662887367, 1147106178, 391545844, (-842634601), 1891500680, (-1278357646), 1851642611, 546529401, 1167818917, (-1100946725), (-1446891263), (-341495460), 575554290, 475796850, (-160294100), 450035699, (-1943715762), 844027695, 1080539133, 86184846, 1554234488, (-602941842), 1972511363, 2018339607, 1491841390, 1141460869, 1061690759, (-50418053), 2008416118, (-1943862593), (-1426819754), 1598468138, 722020353, 1027143159, 212344630, 1387219594, 1725294528, (-549779340), (-1794813680), 458938280, (-165751379), 1828119673, 544571780, (-791741851), (-1997029800), 1241802790, 267843827, (-1600356496), 1397140384, 1558801448, (-512299613), 1806446719, 929573330, (-2060054615), 400817706, 616011623, (-173446368), (-691198571), 1761550015, 1968522284, (-241236290), (-102734438), (-289847011), 872482584, (-1154430280), (-400359915), (-2007561853), 1963876937, (-631079339), 1584857000, (-1319942842), 1833426440, (-269883436)]);
  S6 = initValues('[I', 19, (-1), [(-151351395), 749497569, 1285769319, (-499941508), (-1780807449), 23610292, (-319988548), 844452780, (-1080096416), (-543038739), (-2081400931), 1676510905, 448177848, (-564216263), (-208668878), (-1987464904), 871450977, (-1072089155), (-184105254), (-463315330), (-1559696743), 1310974780, 2043402188, 1218528103, (-1558931943), (-20362283), (-1592518838), (-358606746), (-1601905875), 162023535, (-1467457206), 687910808, 23484817, (-510056349), (-923595680), 779677500, (-791340750), (-821040108), (-137754670), (-794288014), (-46065282), (-1828346192), (-395582502), 1958663117, 925738300, 1283408968, (-625617856), 1840910019, 137959847, (-1615139111), 1239142320, 1315376211, 1547541505, 1690155329, 739140458, (-1166157363), (-361794680), (-418658462), 905091803, 1548541325, (-254505588), (-1199483934), 144808038, 451078856, 676114313, (-1433239005), (-1825259949), 993665471, 373509091, (-1695926010), (-269958290), (-124727847), (-2145227346), (-1019173725), (-545350647), (-1500207097), 1534877388, 572371878, (-1704353745), 1753320020, (-827184785), 1405125690, (-24562091), 633333386, (-1268610372), (-819843393), 632057672, (-1448504441), 1404951397, (-412091417), (-379060872), 195638627, (-1909183551), (-392094743), 1233155085, (-938967556), (-1914388583), (-1592720992), 2144565621, (-631626048), (-400582321), (-1792488055), (-46948371), (-1200081729), 1594115437, 572884632, (-909850565), 767645374, 1331858858, 1475698373, (-501085506), (-762220865), 1321687957, 619889600, 1121017241, (-854753376), 2070816767, (-1461941520), 1933951238, (-199351505), 890643334, (-420837082), 859025556, 360630002, 925594799, 1764062180, (-374745016), (-216661367), 979562269, (-1484266952), (-207227274), 1949714515, 546639971, 1165388173, (-1225075705), 1495988560, 922170659, 1291546247, 2107952832, 1813327274, (-888957272), (-988938659), (-53016661), 153207855, (-1981812549), 1608695416, 1150242611, 1967526857, 721801357, 1220138373, (-603679679), (-938897509), 2112743302, (-1013304461), 1111556101, 1778980689, 250857638, (-1996459306), 673216130, (-1448478786), (-1087215715), (-732210315), (-1286341376), (-877599912), (-2096160246), 529510932, (-747450616), (-868464109), (-1930022554), 102533054, (-2000056440), 1617093527, 1204784762, (-1228385661), 1019391227, 1069574518, 1317995090, 1691889997, (-633835293), 510022745, (-1056372496), 1362108837, 1817929911, (-2110813536), 805817662, 1953603311, (-595122559), 120799444, 2118332377, 207536705, (-2012665748), (-174925679), 145305846, (-1786842363), (-1208221763), (-1033442961), 1877257368, (-1317802816), (-1134513110), (-1791715110), (-73290222), 759945014, 254147243, (-1527513877), (-493448925), 629083197, (-1823953079), 907280572, (-394170550), 940896768, (-1543946173), (-1669704510), (-1133490345), (-633214983), (-1034235078), 1425318020, (-1317055227), 1496677566, (-306375224), 2140652971, (-1168455755), (-1225335121), 977771578, 1392695845, 1698528874, 1411812681, 1369733098, 1343739227, (-674079352), 1142123638, 67414216, (-1192910559), (-1206218102), 1626167401, (-1748673642), (-353593061), 697522451, 33404913, 143560186, (-1699285259), 994885535, 1247667115, (-435872459), (-1595811755), (-747942671), (-180032021), (-1326893788), (-1095004227), (-1562942769), 1237921620, 951448369, 1898488916, 1211705605, (-1503978056), (-2061723715), (-696922321)]);
  S7 = initValues('[I', 19, (-1), [(-2048901095), 858518887, 1714274303, (-809085293), 713916271, (-1415853806), (-564131679), 539548191, 36158695, 1298409750, 419087104, 1358007170, 749914897, (-1305286820), 1261868530, (-1299773474), (-1604338442), (-851344919), (-514842356), (-498142787), (-1318534271), (-35330167), 1551479000, 512490819, 1296650241, 951993153, (-1858277859), (-1834509249), 144139966, (-1158763020), 310820559, (-1226126567), 643875328, 1969602020, 1680088954, (-2109154135), (-1011634842), 672358534, 198762408, 896343282, 276269502, (-1280120370), 84060815, 197145886, 376173866, (-351076478), (-481793775), (-749898474), 1316698879, 1598252827, (-1661542345), 1233235075, 859989710, (-1936506441), (-791128896), (-885363576), 1203513385, 1193654839, (-1502948821), 2060853022, 207403770, 1144516871, (-1226335902), 1121114134, 177607304, (-509230994), 326409831, 1929119770, (-1311688201), (-111659195), (-820388008), (-1094453418), (-1066485200), 119610148, 1170376745, (-916573825), (-1131494127), 951863017, (-957941228), (-1159178166), (-1387348922), 1183797387, 2015970143, (-249292741), (-2111980897), (-1342828556), (-366195091), 384012900, (-1839969653), 10178499, (-1415148307), (-1698074760), 111523738, (-1299878290), 451689641, (-1098676600), 235406569, 1441906262, (-404408773), (-1281232291), (-136397947), 1644036924, 376726067, 1006849064, (-630387596), 2041234796, 1021632941, 1374734338, (-1728515238), 371631263, (-287823063), 490221539, 206551450, (-1154328712), 1053219195, 1853335209, (-882537636), (-732811065), 735133835, 1623211703, (-1190752904), (-1556654860), (-198129539), (-928574718), (-1184003022), (-338368578), (-1098146515), 2038037254, (-417180920), (-1955213449), 300912036, (-528234408), (-1922336657), 1516443558, (-94570592), 1574567987, (-225525840), (-172375280), (-1595227520), 146372218, (-1546005840), 2043888151, 35287437, (-1698286742), 655490400, 1132482787, 110692520, 1031794116, (-2106774545), 1324057718, 1217253157, 919197030, 686247489, (-1033827638), 1028237775, (-1159480865), (-1235251738), (-1834045596), 986174950, (-1633155831), (-232062595), (-1541980304), (-585230653), 367056889, 1353824391, 731860949, 1650113154, 1778481506, 784341916, 357075625, (-686364864), 1074092588, (-1814914526), (-483541094), 92751289, 877911070, (-694605458), 1231880047, 480201094, (-538776313), (-1200471343), 434011822, 87971354, 363687820, 1717726236, 1901380172, (-368563414), (-1813305031), 400339184, 1490350766, (-1633512197), 1389319756, (-1736180122), 784598401, 1983468483, 30828846, (-744439544), (-1578691058), (-453845082), 1765724805, 1955612312, 1277890269, 1333098070, 1564029816, (-1590549681), 1026694237, (-1007296108), 1260819201, (-945880529), 1016692350, 1582273796, 1073413053, 1995943182, 694588404, 1025494639, (-971094594), (-743068876), (-148112969), 453260480, 1316140391, 1435673405, (-1256025343), (-808277889), 1622062951, 403978347, 817677117, 950059133, (-48888078), (-1016901221), 1486738320, 1417279718, 481875527, (-1745002071), (-361276940), 760697757, 1452955855, (-397515859), 1177426808, 1702951038, (-209618668), (-1847962124), 1084371187, (-778531019), (-1226630958), 1073369276, 1027665953, (-1010778706), 1230553676, 1368340146, (-2068720784), 267243139, (-2020746534), (-224233017), (-1797252120), (-1871614133), (-1790211421)]);
  S8 = initValues('[I', 19, (-1), [(-501862387), (-1143078916), (-1477715267), 895778965, 2005530807, (-423554533), 237245952, 86829237, 296341424, (-443207919), (-320366326), (-1819881100), 709006108, 1994621201, (-1322389702), 937287164, (-560275791), 168608556, (-1105629143), (-2069886656), (-1155253745), (-1261357105), (-1269925392), 77524477, 185966941, 1208824168, (-1950622118), 1721625922, (-940775375), 1066374631, 1927223579, 1971335949, (-1811463599), 1551748602, (-1413583517), (-1438637724), (-1291725814), 48746954, 1398218158, 2050065058, 313056748, (-39177379), 393167848, 1912293076, 940740642, (-829121836), (-1203279443), (-1772365726), (-2097950635), 1727764327, 364383054, 492521376, 1291706479, (-1030830920), 1474851438, 1685747964, (-1719247548), 1619776915, 1814040067, 970743798, 1561002147, (-1369198606), 2123093554, 1880132620, (-1143779255), 697884420, (-1743981526), (-1687292783), (-1635852973), 110200136, 1489731079, 997519150, 1378877361, (-767096628), 478029773, (-1528094373), 1022481122, 431258168, 1112503832, 897933369, (-1659379993), 669726182, (-911214981), 918222264, 163866573, (-1047981903), (-518144133), 114105080, 1903216136, 761148244, (-723629734), 1690750982, (-1128217044), 1037045171, 1888456500, 2010454850, 642736655, 616092351, 365016990, 1185228132, (-120068786), 1043824992, 2023083429, (-2053368411), (-431646840), (-1015298209), (-620250612), 108438443, 2132974366, 830746235, 606445527, (-121703310), (-2090861384), 1844756978, (-1762283115), (-49614596), (-1325526196), (-498045635), 1335562986, (-233442779), (-1574734993), (-1615543256), 634407289, 885462008, (-1000242809), (-361075048), 2094100220, 339117932, (-246136569), (-1092686316), 1458155303, (-1605721023), 1022871705, (-1829979418), (-580451987), 353796843, (-1472008481), (-38117196), (-242189451), 551748367, 618185374, (-516331717), (-274317384), 1904685140, (-1225601221), (-1624087486), (-887774004), (-1340455676), (-236683891), (-2075517979), (-1159208996), 1120655984, (-847401462), 1474845562, (-717268234), 550456716, (-828058584), 2043752612, 881257467, 869518812, 2005220179, 938474677, (-989427848), (-444550170), 1315485940, (-976702594), 226533026, 965733244, 321539988, 1136104718, 804158748, 573969341, (-586757470), 937399083, (-1004240247), (-1393300541), 1461057207, (-281773859), (-228105873), (-1052193820), (-1873641122), 1581322155, (-1266015131), 786071460, (-394575644), (-376528764), 1485433313, (-271347460), (-586689701), (-616016236), 953673138, 1467089153, 1930354364, 1533292819, (-1802404273), 1346121658, 1685000834, 1965281866, (-529033579), (-104760689), 2052792609, (-779634538), 690371149, (-1169093409), (-2114683745), (-1391369235), (-361014939), 436236910, 289419410, 14314871, 1242357089, (-1390459389), 1616633776, (-1628585116), 585885352, (-823668086), (-1595459936), 1432659641, 277164553, (-940863689), 770115018, (-1991158001), (-553024981), (-1117185428), (-1441602318), (-2025513969), (-520707462), 987383833, 1290892879, 225909803, 1741533526, 890078084, 1496906255, 1111072499, 916028167, 243534141, 1252605537, (-2090805125), 531204876, 290011180, (-378133083), 102027703, 237315147, 209093447, 1486785922, 220223953, (-1536771298), (-119928190), 82940208, (-1167176000), (-1725542044), 518464269, 1353887104, (-353474559), (-1917672829), (-359926370)]);
}

function $$init_0(this$static){
  this$static._Kr = initDims_0('[I', [19], [(-1)], [17], 0);
  this$static._Km = initDims_0('[I', [19], [(-1)], [17], 0);
}

function $Bits32ToBytes_0(this$static, in_$, b, offset){
  b[offset + 3] = narrow_byte(in_$);
  b[offset + 2] = narrow_byte(in_$ >>> 8);
  b[offset + 1] = narrow_byte(in_$ >>> 16);
  b[offset] = narrow_byte(in_$ >>> 24);
}

function $Bits32ToInts(this$static, in_$, b, offset){
  b[offset + 3] = in_$ & 255;
  b[offset + 2] = in_$ >>> 8 & 255;
  b[offset + 1] = in_$ >>> 16 & 255;
  b[offset] = in_$ >>> 24 & 255;
}

function $BytesTo32bits_0(this$static, b, i){
  return (b[i] & 255) << 24 | (b[i + 1] & 255) << 16 | (b[i + 2] & 255) << 8 | b[i + 3] & 255;
}

function $CAST5Engine(this$static){
  $clinit_33();
  $$init_0(this$static);
  return this$static;
}

function $CAST_Decipher(this$static, L16, R16, result){
  var Li, Lp, Ri, Rp, i;
  Lp = L16;
  Rp = R16;
  Li = L16;
  Ri = R16;
  for (i = this$static._rounds; i > 0; i--) {
    Lp = Li;
    Rp = Ri;
    Li = Rp;
    switch (i) {
      case 1:
      case 4:
      case 7:
      case 10:
      case 13:
      case 16:
        Ri = Lp ^ $F1(this$static, Rp, this$static._Km[i], this$static._Kr[i]);
        break;
      case 2:
      case 5:
      case 8:
      case 11:
      case 14:
        Ri = Lp ^ $F2(this$static, Rp, this$static._Km[i], this$static._Kr[i]);
        break;
      case 3:
      case 6:
      case 9:
      case 12:
      case 15:
        Ri = Lp ^ $F3(this$static, Rp, this$static._Km[i], this$static._Kr[i]);
        break;
    }
  }
  result[0] = Ri;
  result[1] = Li;
  return;
}

function $CAST_Encipher(this$static, L0, R0, result){
  var Li, Lp, Ri, Rp, i;
  Lp = L0;
  Rp = R0;
  Li = L0;
  Ri = R0;
  for (i = 1; i <= this$static._rounds; i++) {
    Lp = Li;
    Rp = Ri;
    Li = Rp;
    switch (i) {
      case 1:
      case 4:
      case 7:
      case 10:
      case 13:
      case 16:
        Ri = Lp ^ $F1(this$static, Rp, this$static._Km[i], this$static._Kr[i]);
        break;
      case 2:
      case 5:
      case 8:
      case 11:
      case 14:
        Ri = Lp ^ $F2(this$static, Rp, this$static._Km[i], this$static._Kr[i]);
        break;
      case 3:
      case 6:
      case 9:
      case 12:
      case 15:
        Ri = Lp ^ $F3(this$static, Rp, this$static._Km[i], this$static._Kr[i]);
        break;
    }
  }
  result[0] = Ri;
  result[1] = Li;
  return;
}

function $F1(this$static, D, Kmi, Kri){
  var I;
  I = Kmi + D;
  I = I << Kri | I >>> 32 - Kri;
  return (S1[I >>> 24 & 255] ^ S2[I >>> 16 & 255]) - S3[I >>> 8 & 255] + S4[I & 255];
}

function $F2(this$static, D, Kmi, Kri){
  var I;
  I = Kmi ^ D;
  I = I << Kri | I >>> 32 - Kri;
  return S1[I >>> 24 & 255] - S2[I >>> 16 & 255] + S3[I >>> 8 & 255] ^ S4[I & 255];
}

function $F3(this$static, D, Kmi, Kri){
  var I;
  I = Kmi - D;
  I = I << Kri | I >>> 32 - Kri;
  return (S1[I >>> 24 & 255] + S2[I >>> 16 & 255] ^ S3[I >>> 8 & 255]) - S4[I & 255];
}

function $IntsTo32bits(this$static, b, i){
  var rv;
  rv = 0;
  rv = (b[i] & 255) << 24 | (b[i + 1] & 255) << 16 | (b[i + 2] & 255) << 8 | b[i + 3] & 255;
  return rv;
}

function $decryptBlock_1(this$static, src, srcIndex, dst, dstIndex){
  var L16, R16, result;
  result = initDims_0('[I', [19], [(-1)], [2], 0);
  L16 = $BytesTo32bits_0(this$static, src, srcIndex);
  R16 = $BytesTo32bits_0(this$static, src, srcIndex + 4);
  $CAST_Decipher(this$static, L16, R16, result);
  $Bits32ToBytes_0(this$static, result[0], dst, dstIndex);
  $Bits32ToBytes_0(this$static, result[1], dst, dstIndex + 4);
  return 8;
}

function $encryptBlock_1(this$static, src, srcIndex, dst, dstIndex){
  var L0, R0, result;
  result = initDims_0('[I', [19], [(-1)], [2], 0);
  L0 = $BytesTo32bits_0(this$static, src, srcIndex);
  R0 = $BytesTo32bits_0(this$static, src, srcIndex + 4);
  $CAST_Encipher(this$static, L0, R0, result);
  $Bits32ToBytes_0(this$static, result[0], dst, dstIndex);
  $Bits32ToBytes_0(this$static, result[1], dst, dstIndex + 4);
  return 8;
}

function $setKey_0(this$static, key){
  var i, x, x03, x47, x8B, xCF, z, z03, z47, z8B, zCF;
  if (key.length_0 < 11) {
    this$static._rounds = 12;
  }
  z = initDims_0('[I', [19], [(-1)], [16], 0);
  x = initDims_0('[I', [19], [(-1)], [16], 0);
  for (i = 0; i < key.length_0; i++) {
    x[i] = key[i] & 255;
  }
  x03 = $IntsTo32bits(this$static, x, 0);
  x47 = $IntsTo32bits(this$static, x, 4);
  x8B = $IntsTo32bits(this$static, x, 8);
  xCF = $IntsTo32bits(this$static, x, 12);
  z03 = x03 ^ S5[x[13]] ^ S6[x[15]] ^ S7[x[12]] ^ S8[x[14]] ^ S7[x[8]];
  $Bits32ToInts(this$static, z03, z, 0);
  z47 = x8B ^ S5[z[0]] ^ S6[z[2]] ^ S7[z[1]] ^ S8[z[3]] ^ S8[x[10]];
  $Bits32ToInts(this$static, z47, z, 4);
  z8B = xCF ^ S5[z[7]] ^ S6[z[6]] ^ S7[z[5]] ^ S8[z[4]] ^ S5[x[9]];
  $Bits32ToInts(this$static, z8B, z, 8);
  zCF = x47 ^ S5[z[10]] ^ S6[z[9]] ^ S7[z[11]] ^ S8[z[8]] ^ S6[x[11]];
  $Bits32ToInts(this$static, zCF, z, 12);
  this$static._Km[1] = S5[z[8]] ^ S6[z[9]] ^ S7[z[7]] ^ S8[z[6]] ^ S5[z[2]];
  this$static._Km[2] = S5[z[10]] ^ S6[z[11]] ^ S7[z[5]] ^ S8[z[4]] ^ S6[z[6]];
  this$static._Km[3] = S5[z[12]] ^ S6[z[13]] ^ S7[z[3]] ^ S8[z[2]] ^ S7[z[9]];
  this$static._Km[4] = S5[z[14]] ^ S6[z[15]] ^ S7[z[1]] ^ S8[z[0]] ^ S8[z[12]];
  z03 = $IntsTo32bits(this$static, z, 0);
  z47 = $IntsTo32bits(this$static, z, 4);
  z8B = $IntsTo32bits(this$static, z, 8);
  zCF = $IntsTo32bits(this$static, z, 12);
  x03 = z8B ^ S5[z[5]] ^ S6[z[7]] ^ S7[z[4]] ^ S8[z[6]] ^ S7[z[0]];
  $Bits32ToInts(this$static, x03, x, 0);
  x47 = z03 ^ S5[x[0]] ^ S6[x[2]] ^ S7[x[1]] ^ S8[x[3]] ^ S8[z[2]];
  $Bits32ToInts(this$static, x47, x, 4);
  x8B = z47 ^ S5[x[7]] ^ S6[x[6]] ^ S7[x[5]] ^ S8[x[4]] ^ S5[z[1]];
  $Bits32ToInts(this$static, x8B, x, 8);
  xCF = zCF ^ S5[x[10]] ^ S6[x[9]] ^ S7[x[11]] ^ S8[x[8]] ^ S6[z[3]];
  $Bits32ToInts(this$static, xCF, x, 12);
  this$static._Km[5] = S5[x[3]] ^ S6[x[2]] ^ S7[x[12]] ^ S8[x[13]] ^ S5[x[8]];
  this$static._Km[6] = S5[x[1]] ^ S6[x[0]] ^ S7[x[14]] ^ S8[x[15]] ^ S6[x[13]];
  this$static._Km[7] = S5[x[7]] ^ S6[x[6]] ^ S7[x[8]] ^ S8[x[9]] ^ S7[x[3]];
  this$static._Km[8] = S5[x[5]] ^ S6[x[4]] ^ S7[x[10]] ^ S8[x[11]] ^ S8[x[7]];
  x03 = $IntsTo32bits(this$static, x, 0);
  x47 = $IntsTo32bits(this$static, x, 4);
  x8B = $IntsTo32bits(this$static, x, 8);
  xCF = $IntsTo32bits(this$static, x, 12);
  z03 = x03 ^ S5[x[13]] ^ S6[x[15]] ^ S7[x[12]] ^ S8[x[14]] ^ S7[x[8]];
  $Bits32ToInts(this$static, z03, z, 0);
  z47 = x8B ^ S5[z[0]] ^ S6[z[2]] ^ S7[z[1]] ^ S8[z[3]] ^ S8[x[10]];
  $Bits32ToInts(this$static, z47, z, 4);
  z8B = xCF ^ S5[z[7]] ^ S6[z[6]] ^ S7[z[5]] ^ S8[z[4]] ^ S5[x[9]];
  $Bits32ToInts(this$static, z8B, z, 8);
  zCF = x47 ^ S5[z[10]] ^ S6[z[9]] ^ S7[z[11]] ^ S8[z[8]] ^ S6[x[11]];
  $Bits32ToInts(this$static, zCF, z, 12);
  this$static._Km[9] = S5[z[3]] ^ S6[z[2]] ^ S7[z[12]] ^ S8[z[13]] ^ S5[z[9]];
  this$static._Km[10] = S5[z[1]] ^ S6[z[0]] ^ S7[z[14]] ^ S8[z[15]] ^ S6[z[12]];
  this$static._Km[11] = S5[z[7]] ^ S6[z[6]] ^ S7[z[8]] ^ S8[z[9]] ^ S7[z[2]];
  this$static._Km[12] = S5[z[5]] ^ S6[z[4]] ^ S7[z[10]] ^ S8[z[11]] ^ S8[z[6]];
  z03 = $IntsTo32bits(this$static, z, 0);
  z47 = $IntsTo32bits(this$static, z, 4);
  z8B = $IntsTo32bits(this$static, z, 8);
  zCF = $IntsTo32bits(this$static, z, 12);
  x03 = z8B ^ S5[z[5]] ^ S6[z[7]] ^ S7[z[4]] ^ S8[z[6]] ^ S7[z[0]];
  $Bits32ToInts(this$static, x03, x, 0);
  x47 = z03 ^ S5[x[0]] ^ S6[x[2]] ^ S7[x[1]] ^ S8[x[3]] ^ S8[z[2]];
  $Bits32ToInts(this$static, x47, x, 4);
  x8B = z47 ^ S5[x[7]] ^ S6[x[6]] ^ S7[x[5]] ^ S8[x[4]] ^ S5[z[1]];
  $Bits32ToInts(this$static, x8B, x, 8);
  xCF = zCF ^ S5[x[10]] ^ S6[x[9]] ^ S7[x[11]] ^ S8[x[8]] ^ S6[z[3]];
  $Bits32ToInts(this$static, xCF, x, 12);
  this$static._Km[13] = S5[x[8]] ^ S6[x[9]] ^ S7[x[7]] ^ S8[x[6]] ^ S5[x[3]];
  this$static._Km[14] = S5[x[10]] ^ S6[x[11]] ^ S7[x[5]] ^ S8[x[4]] ^ S6[x[7]];
  this$static._Km[15] = S5[x[12]] ^ S6[x[13]] ^ S7[x[3]] ^ S8[x[2]] ^ S7[x[8]];
  this$static._Km[16] = S5[x[14]] ^ S6[x[15]] ^ S7[x[1]] ^ S8[x[0]] ^ S8[x[13]];
  x03 = $IntsTo32bits(this$static, x, 0);
  x47 = $IntsTo32bits(this$static, x, 4);
  x8B = $IntsTo32bits(this$static, x, 8);
  xCF = $IntsTo32bits(this$static, x, 12);
  z03 = x03 ^ S5[x[13]] ^ S6[x[15]] ^ S7[x[12]] ^ S8[x[14]] ^ S7[x[8]];
  $Bits32ToInts(this$static, z03, z, 0);
  z47 = x8B ^ S5[z[0]] ^ S6[z[2]] ^ S7[z[1]] ^ S8[z[3]] ^ S8[x[10]];
  $Bits32ToInts(this$static, z47, z, 4);
  z8B = xCF ^ S5[z[7]] ^ S6[z[6]] ^ S7[z[5]] ^ S8[z[4]] ^ S5[x[9]];
  $Bits32ToInts(this$static, z8B, z, 8);
  zCF = x47 ^ S5[z[10]] ^ S6[z[9]] ^ S7[z[11]] ^ S8[z[8]] ^ S6[x[11]];
  $Bits32ToInts(this$static, zCF, z, 12);
  this$static._Kr[1] = (S5[z[8]] ^ S6[z[9]] ^ S7[z[7]] ^ S8[z[6]] ^ S5[z[2]]) & 31;
  this$static._Kr[2] = (S5[z[10]] ^ S6[z[11]] ^ S7[z[5]] ^ S8[z[4]] ^ S6[z[6]]) & 31;
  this$static._Kr[3] = (S5[z[12]] ^ S6[z[13]] ^ S7[z[3]] ^ S8[z[2]] ^ S7[z[9]]) & 31;
  this$static._Kr[4] = (S5[z[14]] ^ S6[z[15]] ^ S7[z[1]] ^ S8[z[0]] ^ S8[z[12]]) & 31;
  z03 = $IntsTo32bits(this$static, z, 0);
  z47 = $IntsTo32bits(this$static, z, 4);
  z8B = $IntsTo32bits(this$static, z, 8);
  zCF = $IntsTo32bits(this$static, z, 12);
  x03 = z8B ^ S5[z[5]] ^ S6[z[7]] ^ S7[z[4]] ^ S8[z[6]] ^ S7[z[0]];
  $Bits32ToInts(this$static, x03, x, 0);
  x47 = z03 ^ S5[x[0]] ^ S6[x[2]] ^ S7[x[1]] ^ S8[x[3]] ^ S8[z[2]];
  $Bits32ToInts(this$static, x47, x, 4);
  x8B = z47 ^ S5[x[7]] ^ S6[x[6]] ^ S7[x[5]] ^ S8[x[4]] ^ S5[z[1]];
  $Bits32ToInts(this$static, x8B, x, 8);
  xCF = zCF ^ S5[x[10]] ^ S6[x[9]] ^ S7[x[11]] ^ S8[x[8]] ^ S6[z[3]];
  $Bits32ToInts(this$static, xCF, x, 12);
  this$static._Kr[5] = (S5[x[3]] ^ S6[x[2]] ^ S7[x[12]] ^ S8[x[13]] ^ S5[x[8]]) & 31;
  this$static._Kr[6] = (S5[x[1]] ^ S6[x[0]] ^ S7[x[14]] ^ S8[x[15]] ^ S6[x[13]]) & 31;
  this$static._Kr[7] = (S5[x[7]] ^ S6[x[6]] ^ S7[x[8]] ^ S8[x[9]] ^ S7[x[3]]) & 31;
  this$static._Kr[8] = (S5[x[5]] ^ S6[x[4]] ^ S7[x[10]] ^ S8[x[11]] ^ S8[x[7]]) & 31;
  x03 = $IntsTo32bits(this$static, x, 0);
  x47 = $IntsTo32bits(this$static, x, 4);
  x8B = $IntsTo32bits(this$static, x, 8);
  xCF = $IntsTo32bits(this$static, x, 12);
  z03 = x03 ^ S5[x[13]] ^ S6[x[15]] ^ S7[x[12]] ^ S8[x[14]] ^ S7[x[8]];
  $Bits32ToInts(this$static, z03, z, 0);
  z47 = x8B ^ S5[z[0]] ^ S6[z[2]] ^ S7[z[1]] ^ S8[z[3]] ^ S8[x[10]];
  $Bits32ToInts(this$static, z47, z, 4);
  z8B = xCF ^ S5[z[7]] ^ S6[z[6]] ^ S7[z[5]] ^ S8[z[4]] ^ S5[x[9]];
  $Bits32ToInts(this$static, z8B, z, 8);
  zCF = x47 ^ S5[z[10]] ^ S6[z[9]] ^ S7[z[11]] ^ S8[z[8]] ^ S6[x[11]];
  $Bits32ToInts(this$static, zCF, z, 12);
  this$static._Kr[9] = (S5[z[3]] ^ S6[z[2]] ^ S7[z[12]] ^ S8[z[13]] ^ S5[z[9]]) & 31;
  this$static._Kr[10] = (S5[z[1]] ^ S6[z[0]] ^ S7[z[14]] ^ S8[z[15]] ^ S6[z[12]]) & 31;
  this$static._Kr[11] = (S5[z[7]] ^ S6[z[6]] ^ S7[z[8]] ^ S8[z[9]] ^ S7[z[2]]) & 31;
  this$static._Kr[12] = (S5[z[5]] ^ S6[z[4]] ^ S7[z[10]] ^ S8[z[11]] ^ S8[z[6]]) & 31;
  z03 = $IntsTo32bits(this$static, z, 0);
  z47 = $IntsTo32bits(this$static, z, 4);
  z8B = $IntsTo32bits(this$static, z, 8);
  zCF = $IntsTo32bits(this$static, z, 12);
  x03 = z8B ^ S5[z[5]] ^ S6[z[7]] ^ S7[z[4]] ^ S8[z[6]] ^ S7[z[0]];
  $Bits32ToInts(this$static, x03, x, 0);
  x47 = z03 ^ S5[x[0]] ^ S6[x[2]] ^ S7[x[1]] ^ S8[x[3]] ^ S8[z[2]];
  $Bits32ToInts(this$static, x47, x, 4);
  x8B = z47 ^ S5[x[7]] ^ S6[x[6]] ^ S7[x[5]] ^ S8[x[4]] ^ S5[z[1]];
  $Bits32ToInts(this$static, x8B, x, 8);
  xCF = zCF ^ S5[x[10]] ^ S6[x[9]] ^ S7[x[11]] ^ S8[x[8]] ^ S6[z[3]];
  $Bits32ToInts(this$static, xCF, x, 12);
  this$static._Kr[13] = (S5[x[8]] ^ S6[x[9]] ^ S7[x[7]] ^ S8[x[6]] ^ S5[x[3]]) & 31;
  this$static._Kr[14] = (S5[x[10]] ^ S6[x[11]] ^ S7[x[5]] ^ S8[x[4]] ^ S6[x[7]]) & 31;
  this$static._Kr[15] = (S5[x[12]] ^ S6[x[13]] ^ S7[x[3]] ^ S8[x[2]] ^ S7[x[8]]) & 31;
  this$static._Kr[16] = (S5[x[14]] ^ S6[x[15]] ^ S7[x[1]] ^ S8[x[0]] ^ S8[x[13]]) & 31;
}

function getBlockSize_1(){
  return 8;
}

function init_2(encrypting, params){
  if (instanceOf(params, 5)) {
    this._encrypting = encrypting;
    this._workingKey = dynamicCast(params, 5).getKey();
    $setKey_0(this, this._workingKey);
    return;
  }
  throw $IllegalArgumentException(new IllegalArgumentException(), 'Invalid parameter passed to CAST5 init - ');
}

function processBlock_1(in_$, inOff, out, outOff){
  var blockSize;
  if (this._workingKey === null) {
    throw $IllegalStateException(new IllegalStateException(), 'CAST5 not initialised');
  }
  blockSize = 8;
  if (inOff + blockSize > in_$.length_0) {
    throw $DataLengthException(new DataLengthException(), 'Input buffer too short');
  }
  if (outOff + blockSize > out.length_0) {
    throw $DataLengthException(new DataLengthException(), 'Output buffer too short');
  }
  if (this._encrypting) {
    return $encryptBlock_1(this, in_$, inOff, out, outOff);
  }
   else {
    return $decryptBlock_1(this, in_$, inOff, out, outOff);
  }
}

function reset_1(){
}

function CAST5Engine(){
}

_ = CAST5Engine.prototype = new Object_0();
_.getBlockSize = getBlockSize_1;
_.init = init_2;
_.processBlock = processBlock_1;
_.reset = reset_1;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'CAST5Engine';
_.typeId$ = 0;
_._encrypting = false;
_._rounds = 16;
_._workingKey = null;
var S1, S2, S3, S4, S5, S6, S7, S8;
function $CFBBlockCipher(this$static, cipher, bitBlockSize){
  this$static.cipher = cipher;
  this$static.blockSize = round_int(bitBlockSize / 8);
  this$static.IV = initDims_0('[B', [0], [(-1)], [cipher.getBlockSize()], 0);
  this$static.cfbV = initDims_0('[B', [0], [(-1)], [cipher.getBlockSize()], 0);
  this$static.cfbOutV = initDims_0('[B', [0], [(-1)], [cipher.getBlockSize()], 0);
  return this$static;
}

function $decryptBlock_2(this$static, in_$, inOff, out, outOff){
  var i;
  if (inOff + this$static.blockSize > in_$.length_0) {
    throw $DataLengthException(new DataLengthException(), 'input buffer too short');
  }
  if (outOff + this$static.blockSize > out.length_0) {
    throw $DataLengthException(new DataLengthException(), 'output buffer too short');
  }
  this$static.cipher.processBlock(this$static.cfbV, 0, this$static.cfbOutV, 0);
  arraycopy(this$static.cfbV, this$static.blockSize, this$static.cfbV, 0, this$static.cfbV.length_0 - this$static.blockSize);
  arraycopy(in_$, inOff, this$static.cfbV, this$static.cfbV.length_0 - this$static.blockSize, this$static.blockSize);
  for (i = 0; i < this$static.blockSize; i++) {
    out[outOff + i] = narrow_byte(this$static.cfbOutV[i] ^ in_$[inOff + i]);
  }
  return this$static.blockSize;
}

function $encryptBlock_2(this$static, in_$, inOff, out, outOff){
  var i;
  if (inOff + this$static.blockSize > in_$.length_0) {
    throw $DataLengthException(new DataLengthException(), 'input buffer too short');
  }
  if (outOff + this$static.blockSize > out.length_0) {
    throw $DataLengthException(new DataLengthException(), 'output buffer too short');
  }
  this$static.cipher.processBlock(this$static.cfbV, 0, this$static.cfbOutV, 0);
  for (i = 0; i < this$static.blockSize; i++) {
    out[outOff + i] = narrow_byte(this$static.cfbOutV[i] ^ in_$[inOff + i]);
  }
  arraycopy(this$static.cfbV, this$static.blockSize, this$static.cfbV, 0, this$static.cfbV.length_0 - this$static.blockSize);
  arraycopy(out, outOff, this$static.cfbV, this$static.cfbV.length_0 - this$static.blockSize, this$static.blockSize);
  return this$static.blockSize;
}

function $reset(this$static){
  arraycopy(this$static.IV, 0, this$static.cfbV, 0, this$static.IV.length_0);
  this$static.cipher.reset();
}

function getBlockSize_2(){
  return this.blockSize;
}

function init_3(encrypting, params){
  var i, iv, ivParam;
  this.encrypting = encrypting;
  if (instanceOf(params, 6)) {
    ivParam = dynamicCast(params, 6);
    iv = ivParam.getIV();
    if (iv.length_0 < this.IV.length_0) {
      arraycopy(iv, 0, this.IV, this.IV.length_0 - iv.length_0, iv.length_0);
      for (i = 0; i < this.IV.length_0 - iv.length_0; i++) {
        this.IV[i] = 0;
      }
    }
     else {
      arraycopy(iv, 0, this.IV, 0, this.IV.length_0);
    }
    $reset(this);
    this.cipher.init(true, ivParam.getParameters());
  }
   else {
    $reset(this);
    this.cipher.init(true, params);
  }
}

function processBlock_2(in_$, inOff, out, outOff){
  return this.encrypting?$encryptBlock_2(this, in_$, inOff, out, outOff):$decryptBlock_2(this, in_$, inOff, out, outOff);
}

function reset_2(){
  $reset(this);
}

function CFBBlockCipher(){
}

_ = CFBBlockCipher.prototype = new Object_0();
_.getBlockSize = getBlockSize_2;
_.init = init_3;
_.processBlock = processBlock_2;
_.reset = reset_2;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'CFBBlockCipher';
_.typeId$ = 0;
_.IV = null;
_.blockSize = 0;
_.cfbOutV = null;
_.cfbV = null;
_.cipher = null;
_.encrypting = false;
function $clinit_36(){
  $clinit_36 = nullMethod;
  bytebit = initValues('[S', 0, (-1), [128, 64, 32, 16, 8, 4, 2, 1]);
  bigbyte = initValues('[I', 19, (-1), [8388608, 4194304, 2097152, 1048576, 524288, 262144, 131072, 65536, 32768, 16384, 8192, 4096, 2048, 1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1]);
  pc1 = initValues('[B', 0, (-1), [56, 48, 40, 32, 24, 16, 8, 0, 57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, 10, 2, 59, 51, 43, 35, 62, 54, 46, 38, 30, 22, 14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 60, 52, 44, 36, 28, 20, 12, 4, 27, 19, 11, 3]);
  totrot = initValues('[B', 0, (-1), [1, 2, 4, 6, 8, 10, 12, 14, 15, 17, 19, 21, 23, 25, 27, 28]);
  pc2 = initValues('[B', 0, (-1), [13, 16, 10, 23, 0, 4, 2, 27, 14, 5, 20, 9, 22, 18, 11, 3, 25, 7, 15, 6, 26, 19, 12, 1, 40, 51, 30, 36, 46, 54, 29, 39, 50, 44, 32, 47, 43, 48, 38, 55, 33, 52, 45, 41, 49, 35, 28, 31]);
  SP1 = initValues('[I', 19, (-1), [16843776, 0, 65536, 16843780, 16842756, 66564, 4, 65536, 1024, 16843776, 16843780, 1024, 16778244, 16842756, 16777216, 4, 1028, 16778240, 16778240, 66560, 66560, 16842752, 16842752, 16778244, 65540, 16777220, 16777220, 65540, 0, 1028, 66564, 16777216, 65536, 16843780, 4, 16842752, 16843776, 16777216, 16777216, 1024, 16842756, 65536, 66560, 16777220, 1024, 4, 16778244, 66564, 16843780, 65540, 16842752, 16778244, 16777220, 1028, 66564, 16843776, 1028, 16778240, 16778240, 0, 65540, 66560, 0, 16842756]);
  SP2 = initValues('[I', 19, (-1), [(-2146402272), (-2147450880), 32768, 1081376, 1048576, 32, (-2146435040), (-2147450848), (-2147483616), (-2146402272), (-2146402304), (-2147483648), (-2147450880), 1048576, 32, (-2146435040), 1081344, 1048608, (-2147450848), 0, (-2147483648), 32768, 1081376, (-2146435072), 1048608, (-2147483616), 0, 1081344, 32800, (-2146402304), (-2146435072), 32800, 0, 1081376, (-2146435040), 1048576, (-2147450848), (-2146435072), (-2146402304), 32768, (-2146435072), (-2147450880), 32, (-2146402272), 1081376, 32, 32768, (-2147483648), 32800, (-2146402304), 1048576, (-2147483616), 1048608, (-2147450848), (-2147483616), 1048608, 1081344, 0, (-2147450880), 32800, (-2147483648), (-2146435040), (-2146402272), 1081344]);
  SP3 = initValues('[I', 19, (-1), [520, 134349312, 0, 134348808, 134218240, 0, 131592, 134218240, 131080, 134217736, 134217736, 131072, 134349320, 131080, 134348800, 520, 134217728, 8, 134349312, 512, 131584, 134348800, 134348808, 131592, 134218248, 131584, 131072, 134218248, 8, 134349320, 512, 134217728, 134349312, 134217728, 131080, 520, 131072, 134349312, 134218240, 0, 512, 131080, 134349320, 134218240, 134217736, 512, 0, 134348808, 134218248, 131072, 134217728, 134349320, 8, 131592, 131584, 134217736, 134348800, 134218248, 520, 134348800, 131592, 8, 134348808, 131584]);
  SP4 = initValues('[I', 19, (-1), [8396801, 8321, 8321, 128, 8396928, 8388737, 8388609, 8193, 0, 8396800, 8396800, 8396929, 129, 0, 8388736, 8388609, 1, 8192, 8388608, 8396801, 128, 8388608, 8193, 8320, 8388737, 1, 8320, 8388736, 8192, 8396928, 8396929, 129, 8388736, 8388609, 8396800, 8396929, 129, 0, 0, 8396800, 8320, 8388736, 8388737, 1, 8396801, 8321, 8321, 128, 8396929, 129, 1, 8192, 8388609, 8193, 8396928, 8388737, 8193, 8320, 8388608, 8396801, 128, 8388608, 8192, 8396928]);
  SP5 = initValues('[I', 19, (-1), [256, 34078976, 34078720, 1107296512, 524288, 256, 1073741824, 34078720, 1074266368, 524288, 33554688, 1074266368, 1107296512, 1107820544, 524544, 1073741824, 33554432, 1074266112, 1074266112, 0, 1073742080, 1107820800, 1107820800, 33554688, 1107820544, 1073742080, 0, 1107296256, 34078976, 33554432, 1107296256, 524544, 524288, 1107296512, 256, 33554432, 1073741824, 34078720, 1107296512, 1074266368, 33554688, 1073741824, 1107820544, 34078976, 1074266368, 256, 33554432, 1107820544, 1107820800, 524544, 1107296256, 1107820800, 34078720, 0, 1074266112, 1107296256, 524544, 33554688, 1073742080, 524288, 0, 1074266112, 34078976, 1073742080]);
  SP6 = initValues('[I', 19, (-1), [536870928, 541065216, 16384, 541081616, 541065216, 16, 541081616, 4194304, 536887296, 4210704, 4194304, 536870928, 4194320, 536887296, 536870912, 16400, 0, 4194320, 536887312, 16384, 4210688, 536887312, 16, 541065232, 541065232, 0, 4210704, 541081600, 16400, 4210688, 541081600, 536870912, 536887296, 16, 541065232, 4210688, 541081616, 4194304, 16400, 536870928, 4194304, 536887296, 536870912, 16400, 536870928, 541081616, 4210688, 541065216, 4210704, 541081600, 0, 541065232, 16, 16384, 541065216, 4210704, 16384, 4194320, 536887312, 0, 541081600, 536870912, 4194320, 536887312]);
  SP7 = initValues('[I', 19, (-1), [2097152, 69206018, 67110914, 0, 2048, 67110914, 2099202, 69208064, 69208066, 2097152, 0, 67108866, 2, 67108864, 69206018, 2050, 67110912, 2099202, 2097154, 67110912, 67108866, 69206016, 69208064, 2097154, 69206016, 2048, 2050, 69208066, 2099200, 2, 67108864, 2099200, 67108864, 2099200, 2097152, 67110914, 67110914, 69206018, 69206018, 2, 2097154, 67108864, 67110912, 2097152, 69208064, 2050, 2099202, 69208064, 2050, 67108866, 69208066, 69206016, 2099200, 0, 2, 69208066, 0, 2099202, 69206016, 2048, 67108866, 67110912, 2048, 2097154]);
  SP8 = initValues('[I', 19, (-1), [268439616, 4096, 262144, 268701760, 268435456, 268439616, 64, 268435456, 262208, 268697600, 268701760, 266240, 268701696, 266304, 4096, 64, 268697600, 268435520, 268439552, 4160, 266240, 262208, 268697664, 268701696, 4160, 0, 0, 268697664, 268435520, 268439552, 266304, 262144, 266304, 262144, 268701696, 4096, 64, 268697664, 4096, 266304, 268439552, 64, 268435520, 268697600, 268697664, 268435456, 262144, 268439616, 0, 268701760, 262208, 268435520, 268697600, 268439552, 268439616, 0, 268701760, 266240, 266240, 4160, 4160, 262208, 268435456, 268701696]);
}

function $DESEngine(this$static){
  $clinit_36();
  return this$static;
}

function $desFunc(this$static, wKey, in_$, inOff, out, outOff){
  var fval, left, right, round, work;
  left = (in_$[inOff + 0] & 255) << 24;
  left |= (in_$[inOff + 1] & 255) << 16;
  left |= (in_$[inOff + 2] & 255) << 8;
  left |= in_$[inOff + 3] & 255;
  right = (in_$[inOff + 4] & 255) << 24;
  right |= (in_$[inOff + 5] & 255) << 16;
  right |= (in_$[inOff + 6] & 255) << 8;
  right |= in_$[inOff + 7] & 255;
  work = (left >>> 4 ^ right) & 252645135;
  right ^= work;
  left ^= work << 4;
  work = (left >>> 16 ^ right) & 65535;
  right ^= work;
  left ^= work << 16;
  work = (right >>> 2 ^ left) & 858993459;
  left ^= work;
  right ^= work << 2;
  work = (right >>> 8 ^ left) & 16711935;
  left ^= work;
  right ^= work << 8;
  right = (right << 1 | right >>> 31 & 1) & (-1);
  work = (left ^ right) & (-1431655766);
  left ^= work;
  right ^= work;
  left = (left << 1 | left >>> 31 & 1) & (-1);
  for (round = 0; round < 8; round++) {
    work = right << 28 | right >>> 4;
    work ^= wKey[round * 4 + 0];
    fval = SP7[work & 63];
    fval |= SP5[work >>> 8 & 63];
    fval |= SP3[work >>> 16 & 63];
    fval |= SP1[work >>> 24 & 63];
    work = right ^ wKey[round * 4 + 1];
    fval |= SP8[work & 63];
    fval |= SP6[work >>> 8 & 63];
    fval |= SP4[work >>> 16 & 63];
    fval |= SP2[work >>> 24 & 63];
    left ^= fval;
    work = left << 28 | left >>> 4;
    work ^= wKey[round * 4 + 2];
    fval = SP7[work & 63];
    fval |= SP5[work >>> 8 & 63];
    fval |= SP3[work >>> 16 & 63];
    fval |= SP1[work >>> 24 & 63];
    work = left ^ wKey[round * 4 + 3];
    fval |= SP8[work & 63];
    fval |= SP6[work >>> 8 & 63];
    fval |= SP4[work >>> 16 & 63];
    fval |= SP2[work >>> 24 & 63];
    right ^= fval;
  }
  right = right << 31 | right >>> 1;
  work = (left ^ right) & (-1431655766);
  left ^= work;
  right ^= work;
  left = left << 31 | left >>> 1;
  work = (left >>> 8 ^ right) & 16711935;
  right ^= work;
  left ^= work << 8;
  work = (left >>> 2 ^ right) & 858993459;
  right ^= work;
  left ^= work << 2;
  work = (right >>> 16 ^ left) & 65535;
  left ^= work;
  right ^= work << 16;
  work = (right >>> 4 ^ left) & 252645135;
  left ^= work;
  right ^= work << 4;
  out[outOff + 0] = narrow_byte(right >>> 24 & 255);
  out[outOff + 1] = narrow_byte(right >>> 16 & 255);
  out[outOff + 2] = narrow_byte(right >>> 8 & 255);
  out[outOff + 3] = narrow_byte(right & 255);
  out[outOff + 4] = narrow_byte(left >>> 24 & 255);
  out[outOff + 5] = narrow_byte(left >>> 16 & 255);
  out[outOff + 6] = narrow_byte(left >>> 8 & 255);
  out[outOff + 7] = narrow_byte(left & 255);
}

function $generateWorkingKey_0(this$static, encrypting, key){
  var i, i1, i2, j, l, m, n, newKey, pc1m, pcr;
  newKey = initDims_0('[I', [19], [(-1)], [32], 0);
  pc1m = initDims_0('[Z', [0], [(-1)], [56], false);
  pcr = initDims_0('[Z', [0], [(-1)], [56], false);
  for (j = 0; j < 56; j++) {
    l = pc1[j];
    pc1m[j] = (key[l >>> 3] & bytebit[l & 7]) != 0;
  }
  for (i = 0; i < 16; i++) {
    if (encrypting) {
      m = i << 1;
    }
     else {
      m = 15 - i << 1;
    }
    n = m + 1;
    newKey[m] = newKey[n] = 0;
    for (j = 0; j < 28; j++) {
      l = j + totrot[i];
      if (l < 28) {
        pcr[j] = pc1m[l];
      }
       else {
        pcr[j] = pc1m[l - 28];
      }
    }
    for (j = 28; j < 56; j++) {
      l = j + totrot[i];
      if (l < 56) {
        pcr[j] = pc1m[l];
      }
       else {
        pcr[j] = pc1m[l - 28];
      }
    }
    for (j = 0; j < 24; j++) {
      if (pcr[pc2[j]]) {
        newKey[m] |= bigbyte[j];
      }
      if (pcr[pc2[j + 24]]) {
        newKey[n] |= bigbyte[j];
      }
    }
  }
  for (i = 0; i != 32; i += 2) {
    i1 = newKey[i];
    i2 = newKey[i + 1];
    newKey[i] = (i1 & 16515072) << 6 | (i1 & 4032) << 10 | (i2 & 16515072) >>> 10 | (i2 & 4032) >>> 6;
    newKey[i + 1] = (i1 & 258048) << 12 | (i1 & 63) << 16 | (i2 & 258048) >>> 4 | i2 & 63;
  }
  return newKey;
}

function getBlockSize_3(){
  return 8;
}

function init_4(encrypting, params){
  if (instanceOf(params, 5)) {
    if (dynamicCast(params, 5).getKey().length_0 > 8) {
      throw $IllegalArgumentException(new IllegalArgumentException(), 'DES key too long - should be 8 bytes');
    }
    this.workingKey = $generateWorkingKey_0(this, encrypting, dynamicCast(params, 5).getKey());
    return;
  }
  throw $IllegalArgumentException(new IllegalArgumentException(), 'invalid parameter passed to DES init - ');
}

function processBlock_3(in_$, inOff, out, outOff){
  if (this.workingKey === null) {
    throw $IllegalStateException(new IllegalStateException(), 'DES engine not initialised');
  }
  if (inOff + 8 > in_$.length_0) {
    throw $DataLengthException(new DataLengthException(), 'input buffer too short');
  }
  if (outOff + 8 > out.length_0) {
    throw $DataLengthException(new DataLengthException(), 'output buffer too short');
  }
  $desFunc(this, this.workingKey, in_$, inOff, out, outOff);
  return 8;
}

function reset_3(){
}

function DESEngine(){
}

_ = DESEngine.prototype = new Object_0();
_.getBlockSize = getBlockSize_3;
_.init = init_4;
_.processBlock = processBlock_3;
_.reset = reset_3;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'DESEngine';
_.typeId$ = 0;
_.workingKey = null;
var SP1, SP2, SP3, SP4, SP5, SP6, SP7, SP8, bigbyte, bytebit, pc1, pc2, totrot;
function $clinit_37(){
  $clinit_37 = nullMethod;
  $clinit_36();
}

function $DESedeEngine(this$static){
  $clinit_37();
  $DESEngine(this$static);
  return this$static;
}

function getBlockSize_4(){
  return 8;
}

function init_5(encrypting, params){
  var key1, key2, key3, keyMaster;
  if (!instanceOf(params, 5)) {
    throw $IllegalArgumentException(new IllegalArgumentException(), 'invalid parameter passed to DESede init - ');
  }
  keyMaster = dynamicCast(params, 5).getKey();
  key1 = initDims_0('[B', [0], [(-1)], [8], 0);
  key2 = initDims_0('[B', [0], [(-1)], [8], 0);
  key3 = initDims_0('[B', [0], [(-1)], [8], 0);
  if (keyMaster.length_0 > 24) {
    throw $IllegalArgumentException(new IllegalArgumentException(), 'key size greater than 24 bytes');
  }
  this.forEncryption = encrypting;
  if (keyMaster.length_0 == 24) {
    arraycopy(keyMaster, 0, key1, 0, key1.length_0);
    arraycopy(keyMaster, 8, key2, 0, key2.length_0);
    arraycopy(keyMaster, 16, key3, 0, key3.length_0);
    this.workingKey1 = $generateWorkingKey_0(this, encrypting, key1);
    this.workingKey2 = $generateWorkingKey_0(this, !encrypting, key2);
    this.workingKey3 = $generateWorkingKey_0(this, encrypting, key3);
  }
   else {
    arraycopy(keyMaster, 0, key1, 0, key1.length_0);
    arraycopy(keyMaster, 8, key2, 0, key2.length_0);
    this.workingKey1 = $generateWorkingKey_0(this, encrypting, key1);
    this.workingKey2 = $generateWorkingKey_0(this, !encrypting, key2);
    this.workingKey3 = this.workingKey1;
  }
}

function processBlock_4(in_$, inOff, out, outOff){
  if (this.workingKey1 === null) {
    throw $IllegalStateException(new IllegalStateException(), 'DESede engine not initialised');
  }
  if (inOff + 8 > in_$.length_0) {
    throw $DataLengthException(new DataLengthException(), 'input buffer too short');
  }
  if (outOff + 8 > out.length_0) {
    throw $DataLengthException(new DataLengthException(), 'output buffer too short');
  }
  if (this.forEncryption) {
    $desFunc(this, this.workingKey1, in_$, inOff, out, outOff);
    $desFunc(this, this.workingKey2, out, outOff, out, outOff);
    $desFunc(this, this.workingKey3, out, outOff, out, outOff);
  }
   else {
    $desFunc(this, this.workingKey3, in_$, inOff, out, outOff);
    $desFunc(this, this.workingKey2, out, outOff, out, outOff);
    $desFunc(this, this.workingKey1, out, outOff, out, outOff);
  }
  return 8;
}

function reset_4(){
}

function DESedeEngine(){
}

_ = DESedeEngine.prototype = new DESEngine();
_.getBlockSize = getBlockSize_4;
_.init = init_5;
_.processBlock = processBlock_4;
_.reset = reset_4;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'DESedeEngine';
_.typeId$ = 0;
_.forEncryption = false;
_.workingKey1 = null;
_.workingKey2 = null;
_.workingKey3 = null;
function $DataLengthException(this$static, message){
  $RuntimeException(this$static, message);
  return this$static;
}

function DataLengthException(){
}

_ = DataLengthException.prototype = new RuntimeException();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'DataLengthException';
_.typeId$ = 15;
function $GeneralDigest(this$static){
  this$static.xBuf = initDims_0('[B', [0], [(-1)], [4], 0);
  this$static.xBufOff = 0;
  return this$static;
}

function $finish(this$static){
  var bitLength;
  bitLength = this$static.byteCount << 3;
  $update(this$static, (-128));
  while (this$static.xBufOff != 0) {
    $update(this$static, 0);
  }
  $processLength(this$static, bitLength);
  $processBlock(this$static);
}

function $reset_0(this$static){
  var i;
  this$static.byteCount = 0;
  this$static.xBufOff = 0;
  for (i = 0; i < this$static.xBuf.length_0; i++) {
    this$static.xBuf[i] = 0;
  }
}

function $update(this$static, in_$){
  this$static.xBuf[this$static.xBufOff++] = in_$;
  if (this$static.xBufOff == this$static.xBuf.length_0) {
    $processWord(this$static, this$static.xBuf, 0);
    this$static.xBufOff = 0;
  }
  this$static.byteCount++;
}

function $update_0(this$static, in_$, inOff, len){
  while (this$static.xBufOff != 0 && len > 0) {
    $update(this$static, in_$[inOff]);
    inOff++;
    len--;
  }
  while (len > this$static.xBuf.length_0) {
    $processWord(this$static, in_$, inOff);
    inOff += this$static.xBuf.length_0;
    len -= this$static.xBuf.length_0;
    this$static.byteCount += this$static.xBuf.length_0;
  }
  while (len > 0) {
    $update(this$static, in_$[inOff]);
    inOff++;
    len--;
  }
}

function GeneralDigest(){
}

_ = GeneralDigest.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'GeneralDigest';
_.typeId$ = 0;
_.byteCount = 0;
_.xBuf = null;
_.xBufOff = 0;
function $OpenPGPCFBBlockCipher(this$static, cipher){
  this$static.cipher = cipher;
  this$static.blockSize = cipher.getBlockSize();
  this$static.IV = initDims_0('[B', [0], [(-1)], [this$static.blockSize], 0);
  this$static.FR = initDims_0('[B', [0], [(-1)], [this$static.blockSize], 0);
  this$static.FRE = initDims_0('[B', [0], [(-1)], [this$static.blockSize], 0);
  this$static.tmp = initDims_0('[B', [0], [(-1)], [this$static.blockSize], 0);
  return this$static;
}

function $decryptBlock_3(this$static, in_$, inOff, out, outOff){
  var n;
  if (inOff + this$static.blockSize > in_$.length_0) {
    throw $DataLengthException(new DataLengthException(), 'input buffer too short');
  }
  if (outOff + this$static.blockSize > out.length_0) {
    throw $DataLengthException(new DataLengthException(), 'output buffer too short');
  }
  if (this$static.count > this$static.blockSize) {
    arraycopy(in_$, inOff, this$static.tmp, 0, this$static.blockSize);
    out[outOff] = $encryptByte(this$static, this$static.tmp[0], this$static.blockSize - 2);
    out[outOff + 1] = $encryptByte(this$static, this$static.tmp[1], this$static.blockSize - 1);
    arraycopy(this$static.tmp, 0, this$static.FR, this$static.blockSize - 2, 2);
    this$static.cipher.processBlock(this$static.FR, 0, this$static.FRE, 0);
    for (n = 2; n < this$static.blockSize; n++) {
      out[outOff + n] = $encryptByte(this$static, this$static.tmp[n], n - 2);
    }
    arraycopy(this$static.tmp, 2, this$static.FR, 0, this$static.blockSize - 2);
  }
   else if (this$static.count == 0) {
    this$static.cipher.processBlock(this$static.FR, 0, this$static.FRE, 0);
    for (n = 0; n < this$static.blockSize; n++) {
      this$static.FR[n] = in_$[inOff + n];
      out[n] = $encryptByte(this$static, in_$[inOff + n], n);
    }
    this$static.count += this$static.blockSize;
  }
   else if (this$static.count == this$static.blockSize) {
    arraycopy(in_$, inOff, this$static.tmp, 0, this$static.blockSize);
    this$static.cipher.processBlock(this$static.FR, 0, this$static.FRE, 0);
    out[outOff] = $encryptByte(this$static, this$static.tmp[0], 0);
    out[outOff + 1] = $encryptByte(this$static, this$static.tmp[1], 1);
    arraycopy(this$static.FR, 2, this$static.FR, 0, this$static.blockSize - 2);
    this$static.FR[this$static.blockSize - 2] = this$static.tmp[0];
    this$static.FR[this$static.blockSize - 1] = this$static.tmp[1];
    this$static.cipher.processBlock(this$static.FR, 0, this$static.FRE, 0);
    for (n = 2; n < this$static.blockSize; n++) {
      this$static.FR[n - 2] = in_$[inOff + n];
      out[outOff + n] = $encryptByte(this$static, in_$[inOff + n], n - 2);
    }
    this$static.count += this$static.blockSize;
  }
  return this$static.blockSize;
}

function $encryptBlock_3(this$static, in_$, inOff, out, outOff){
  var n;
  if (inOff + this$static.blockSize > in_$.length_0) {
    throw $DataLengthException(new DataLengthException(), 'input buffer too short');
  }
  if (outOff + this$static.blockSize > out.length_0) {
    throw $DataLengthException(new DataLengthException(), 'output buffer too short');
  }
  if (this$static.count > this$static.blockSize) {
    this$static.FR[this$static.blockSize - 2] = out[outOff] = $encryptByte(this$static, in_$[inOff], this$static.blockSize - 2);
    this$static.FR[this$static.blockSize - 1] = out[outOff + 1] = $encryptByte(this$static, in_$[inOff + 1], this$static.blockSize - 1);
    this$static.cipher.processBlock(this$static.FR, 0, this$static.FRE, 0);
    for (n = 2; n < this$static.blockSize; n++) {
      out[outOff + n] = $encryptByte(this$static, in_$[inOff + n], n - 2);
    }
    arraycopy(out, outOff + 2, this$static.FR, 0, this$static.blockSize - 2);
  }
   else if (this$static.count == 0) {
    this$static.cipher.processBlock(this$static.FR, 0, this$static.FRE, 0);
    for (n = 0; n < this$static.blockSize; n++) {
      out[outOff + n] = $encryptByte(this$static, in_$[inOff + n], n);
    }
    arraycopy(out, outOff, this$static.FR, 0, this$static.blockSize);
    this$static.count += this$static.blockSize;
  }
   else if (this$static.count == this$static.blockSize) {
    this$static.cipher.processBlock(this$static.FR, 0, this$static.FRE, 0);
    out[outOff] = $encryptByte(this$static, in_$[inOff], 0);
    out[outOff + 1] = $encryptByte(this$static, in_$[inOff + 1], 1);
    arraycopy(this$static.FR, 2, this$static.FR, 0, this$static.blockSize - 2);
    arraycopy(out, outOff, this$static.FR, this$static.blockSize - 2, 2);
    this$static.cipher.processBlock(this$static.FR, 0, this$static.FRE, 0);
    for (n = 2; n < this$static.blockSize; n++) {
      out[outOff + n] = $encryptByte(this$static, in_$[inOff + n], n - 2);
    }
    arraycopy(out, outOff + 2, this$static.FR, 0, this$static.blockSize - 2);
    this$static.count += this$static.blockSize;
  }
  return this$static.blockSize;
}

function $encryptByte(this$static, data, blockOff){
  return narrow_byte(this$static.FRE[blockOff] ^ data);
}

function $reset_1(this$static){
  this$static.count = 0;
  arraycopy(this$static.IV, 0, this$static.FR, 0, this$static.FR.length_0);
  this$static.cipher.reset();
}

function getBlockSize_5(){
  return this.cipher.getBlockSize();
}

function init_6(forEncryption, params){
  this.forEncryption = forEncryption;
  $reset_1(this);
  this.cipher.init(true, params);
}

function processBlock_5(in_$, inOff, out, outOff){
  return this.forEncryption?$encryptBlock_3(this, in_$, inOff, out, outOff):$decryptBlock_3(this, in_$, inOff, out, outOff);
}

function reset_5(){
  $reset_1(this);
}

function OpenPGPCFBBlockCipher(){
}

_ = OpenPGPCFBBlockCipher.prototype = new Object_0();
_.getBlockSize = getBlockSize_5;
_.init = init_6;
_.processBlock = processBlock_5;
_.reset = reset_5;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'OpenPGPCFBBlockCipher';
_.typeId$ = 0;
_.FR = null;
_.FRE = null;
_.IV = null;
_.blockSize = 0;
_.cipher = null;
_.count = 0;
_.forEncryption = false;
_.tmp = null;
function $ParamsImpl(this$static, key, iv){
  this$static.m_key = key;
  this$static.m_iv = iv;
  return this$static;
}

function getIV(){
  return this.m_iv;
}

function getKey(){
  return this.m_key;
}

function getParameters(){
  return this;
}

function ParamsImpl(){
}

_ = ParamsImpl.prototype = new Object_0();
_.getIV = getIV;
_.getKey = getKey;
_.getParameters = getParameters;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'ParamsImpl';
_.typeId$ = 16;
_.m_iv = null;
_.m_key = null;
function $$init_1(this$static){
  this$static.X = initDims_0('[I', [19], [(-1)], [80], 0);
}

function $SHA1Digest(this$static){
  $GeneralDigest(this$static);
  $$init_1(this$static);
  $reset_2(this$static);
  return this$static;
}

function $doFinal(this$static, out, outOff){
  $finish(this$static);
  $unpackWord(this$static, this$static.H1, out, outOff);
  $unpackWord(this$static, this$static.H2, out, outOff + 4);
  $unpackWord(this$static, this$static.H3, out, outOff + 8);
  $unpackWord(this$static, this$static.H4, out, outOff + 12);
  $unpackWord(this$static, this$static.H5, out, outOff + 16);
  $reset_2(this$static);
  return 20;
}

function $f(this$static, u, v, w){
  return u & v | ~u & w;
}

function $g(this$static, u, v, w){
  return u & v | u & w | v & w;
}

function $h(this$static, u, v, w){
  return u ^ v ^ w;
}

function $processBlock(this$static){
  var A, B, C, D, E, i, idx, j, t;
  for (i = 16; i < 80; i++) {
    t = this$static.X[i - 3] ^ this$static.X[i - 8] ^ this$static.X[i - 14] ^ this$static.X[i - 16];
    this$static.X[i] = t << 1 | t >>> 31;
  }
  A = this$static.H1;
  B = this$static.H2;
  C = this$static.H3;
  D = this$static.H4;
  E = this$static.H5;
  idx = 0;
  for (j = 0; j < 4; j++) {
    E += (A << 5 | A >>> 27) + $f(this$static, B, C, D) + this$static.X[idx++] + 1518500249;
    B = B << 30 | B >>> 2;
    D += (E << 5 | E >>> 27) + $f(this$static, A, B, C) + this$static.X[idx++] + 1518500249;
    A = A << 30 | A >>> 2;
    C += (D << 5 | D >>> 27) + $f(this$static, E, A, B) + this$static.X[idx++] + 1518500249;
    E = E << 30 | E >>> 2;
    B += (C << 5 | C >>> 27) + $f(this$static, D, E, A) + this$static.X[idx++] + 1518500249;
    D = D << 30 | D >>> 2;
    A += (B << 5 | B >>> 27) + $f(this$static, C, D, E) + this$static.X[idx++] + 1518500249;
    C = C << 30 | C >>> 2;
  }
  for (j = 0; j < 4; j++) {
    E += (A << 5 | A >>> 27) + $h(this$static, B, C, D) + this$static.X[idx++] + 1859775393;
    B = B << 30 | B >>> 2;
    D += (E << 5 | E >>> 27) + $h(this$static, A, B, C) + this$static.X[idx++] + 1859775393;
    A = A << 30 | A >>> 2;
    C += (D << 5 | D >>> 27) + $h(this$static, E, A, B) + this$static.X[idx++] + 1859775393;
    E = E << 30 | E >>> 2;
    B += (C << 5 | C >>> 27) + $h(this$static, D, E, A) + this$static.X[idx++] + 1859775393;
    D = D << 30 | D >>> 2;
    A += (B << 5 | B >>> 27) + $h(this$static, C, D, E) + this$static.X[idx++] + 1859775393;
    C = C << 30 | C >>> 2;
  }
  for (j = 0; j < 4; j++) {
    E += (A << 5 | A >>> 27) + $g(this$static, B, C, D) + this$static.X[idx++] + (-1894007588);
    B = B << 30 | B >>> 2;
    D += (E << 5 | E >>> 27) + $g(this$static, A, B, C) + this$static.X[idx++] + (-1894007588);
    A = A << 30 | A >>> 2;
    C += (D << 5 | D >>> 27) + $g(this$static, E, A, B) + this$static.X[idx++] + (-1894007588);
    E = E << 30 | E >>> 2;
    B += (C << 5 | C >>> 27) + $g(this$static, D, E, A) + this$static.X[idx++] + (-1894007588);
    D = D << 30 | D >>> 2;
    A += (B << 5 | B >>> 27) + $g(this$static, C, D, E) + this$static.X[idx++] + (-1894007588);
    C = C << 30 | C >>> 2;
  }
  for (j = 0; j <= 3; j++) {
    E += (A << 5 | A >>> 27) + $h(this$static, B, C, D) + this$static.X[idx++] + (-899497514);
    B = B << 30 | B >>> 2;
    D += (E << 5 | E >>> 27) + $h(this$static, A, B, C) + this$static.X[idx++] + (-899497514);
    A = A << 30 | A >>> 2;
    C += (D << 5 | D >>> 27) + $h(this$static, E, A, B) + this$static.X[idx++] + (-899497514);
    E = E << 30 | E >>> 2;
    B += (C << 5 | C >>> 27) + $h(this$static, D, E, A) + this$static.X[idx++] + (-899497514);
    D = D << 30 | D >>> 2;
    A += (B << 5 | B >>> 27) + $h(this$static, C, D, E) + this$static.X[idx++] + (-899497514);
    C = C << 30 | C >>> 2;
  }
  this$static.H1 += A;
  this$static.H2 += B;
  this$static.H3 += C;
  this$static.H4 += D;
  this$static.H5 += E;
  this$static.xOff = 0;
  for (i = 0; i < 16; i++) {
    this$static.X[i] = 0;
  }
}

function $processLength(this$static, bitLength){
  if (this$static.xOff > 14) {
    $processBlock(this$static);
  }
  this$static.X[14] = narrow_int(bitLength >>> 32);
  this$static.X[15] = narrow_int(bitLength & (-1));
}

function $processWord(this$static, in_$, inOff){
  this$static.X[this$static.xOff++] = (in_$[inOff] & 255) << 24 | (in_$[inOff + 1] & 255) << 16 | (in_$[inOff + 2] & 255) << 8 | in_$[inOff + 3] & 255;
  if (this$static.xOff == 16) {
    $processBlock(this$static);
  }
}

function $reset_2(this$static){
  var i;
  $reset_0(this$static);
  this$static.H1 = 1732584193;
  this$static.H2 = (-271733879);
  this$static.H3 = (-1732584194);
  this$static.H4 = 271733878;
  this$static.H5 = (-1009589776);
  this$static.xOff = 0;
  for (i = 0; i != this$static.X.length_0; i++) {
    this$static.X[i] = 0;
  }
}

function $unpackWord(this$static, word, out, outOff){
  out[outOff++] = narrow_byte(word >>> 24);
  out[outOff++] = narrow_byte(word >>> 16);
  out[outOff++] = narrow_byte(word >>> 8);
  out[outOff++] = narrow_byte(word);
}

function SHA1Digest(){
}

_ = SHA1Digest.prototype = new GeneralDigest();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'SHA1Digest';
_.typeId$ = 0;
_.H1 = 0;
_.H2 = 0;
_.H3 = 0;
_.H4 = 0;
_.H5 = 0;
_.xOff = 0;
function $clinit_45(){
  $clinit_45 = nullMethod;
  $SomewhatSecureRandom(new SomewhatSecureRandom());
}

function $$init_2(this$static){
  this$static.digest = $SHA1Digest(new SHA1Digest());
  this$static.state = initDims_0('[B', [0], [(-1)], [20], 0);
  this$static.longBytes = initDims_0('[B', [0], [(-1)], [8], 0);
}

function $SomewhatSecureRandom(this$static){
  $clinit_45();
  $$init_2(this$static);
  $setSeed(this$static, currentTimeMillis());
  return this$static;
}

function $longToBytes(this$static, val){
  var i;
  for (i = 0; i != 8; i++) {
    this$static.longBytes[i] = narrow_byte(val);
    val >>>= 8;
  }
  return this$static.longBytes;
}

function $nextBytes(this$static, bytes){
  var b, i, stateOff;
  stateOff = 0;
  $doFinal(this$static.digest, this$static.state, 0);
  for (i = 0; i != bytes.length_0; i++) {
    if (stateOff == this$static.state.length_0) {
      b = $longToBytes(this$static, this$static.counter++);
      $update_0(this$static.digest, b, 0, b.length_0);
      $update_0(this$static.digest, this$static.state, 0, this$static.state.length_0);
      $doFinal(this$static.digest, this$static.state, 0);
      stateOff = 0;
    }
    bytes[i] = this$static.state[stateOff++];
  }
  b = $longToBytes(this$static, this$static.counter++);
  $update_0(this$static.digest, b, 0, b.length_0);
  $update_0(this$static.digest, this$static.state, 0, this$static.state.length_0);
}

function $setSeed_0(this$static, inSeed){
  $update_0(this$static.digest, inSeed, 0, inSeed.length_0);
}

function $setSeed(this$static, rSeed){
  if (rSeed != 0) {
    $setSeed_0(this$static, $longToBytes(this$static, rSeed));
  }
}

function getInstance(){
  $clinit_45();
  return $SomewhatSecureRandom(new SomewhatSecureRandom());
}

function SomewhatSecureRandom(){
}

_ = SomewhatSecureRandom.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'SomewhatSecureRandom';
_.typeId$ = 0;
_.counter = 1;
function $clinit_46(){
  $clinit_46 = nullMethod;
  P = initValues('[[B', 0, 8, [initValues('[B', 0, (-1), [(-87), 103, (-77), (-24), 4, (-3), (-93), 118, (-102), (-110), (-128), 120, (-28), (-35), (-47), 56, 13, (-58), 53, (-104), 24, (-9), (-20), 108, 67, 117, 55, 38, (-6), 19, (-108), 72, (-14), (-48), (-117), 48, (-124), 84, (-33), 35, 25, 91, 61, 89, (-13), (-82), (-94), (-126), 99, 1, (-125), 46, (-39), 81, (-101), 124, (-90), (-21), (-91), (-66), 22, 12, (-29), 97, (-64), (-116), 58, (-11), 115, 44, 37, 11, (-69), 78, (-119), 107, 83, 106, (-76), (-15), (-31), (-26), (-67), 69, (-30), (-12), (-74), 102, (-52), (-107), 3, 86, (-44), 28, 30, (-41), (-5), (-61), (-114), (-75), (-23), (-49), (-65), (-70), (-22), 119, 57, (-81), 51, (-55), 98, 113, (-127), 121, 9, (-83), 36, (-51), (-7), (-40), (-27), (-59), (-71), 77, 68, 8, (-122), (-25), (-95), 29, (-86), (-19), 6, 112, (-78), (-46), 65, 123, (-96), 17, 49, (-62), 39, (-112), 32, (-10), 96, (-1), (-106), 92, (-79), (-85), (-98), (-100), 82, 27, 95, (-109), 10, (-17), (-111), (-123), 73, (-18), 45, 79, (-113), 59, 71, (-121), 109, 70, (-42), 62, 105, 100, 42, (-50), (-53), 47, (-4), (-105), 5, 122, (-84), 127, (-43), 26, 75, 14, (-89), 90, 40, 20, 63, 41, (-120), 60, 76, 2, (-72), (-38), (-80), 23, 85, 31, (-118), 125, 87, (-57), (-115), 116, (-73), (-60), (-97), 114, 126, 21, 34, 18, 88, 7, (-103), 52, 110, 80, (-34), 104, 101, (-68), (-37), (-8), (-56), (-88), 43, 64, (-36), (-2), 50, (-92), (-54), 16, 33, (-16), (-45), 93, 15, 0, 111, (-99), 54, 66, 74, 94, (-63), (-32)]), initValues('[B', 0, (-1), [117, (-13), (-58), (-12), (-37), 123, (-5), (-56), 74, (-45), (-26), 107, 69, 125, (-24), 75, (-42), 50, (-40), (-3), 55, 113, (-15), (-31), 48, 15, (-8), 27, (-121), (-6), 6, 63, 94, (-70), (-82), 91, (-118), 0, (-68), (-99), 109, (-63), (-79), 14, (-128), 93, (-46), (-43), (-96), (-124), 7, 20, (-75), (-112), 44, (-93), (-78), 115, 76, 84, (-110), 116, 54, 81, 56, (-80), (-67), 90, (-4), 96, 98, (-106), 108, 66, (-9), 16, 124, 40, 39, (-116), 19, (-107), (-100), (-57), 36, 70, 59, 112, (-54), (-29), (-123), (-53), 17, (-48), (-109), (-72), (-90), (-125), 32, (-1), (-97), 119, (-61), (-52), 3, 111, 8, (-65), 64, (-25), 43, (-30), 121, 12, (-86), (-126), 65, 58, (-22), (-71), (-28), (-102), (-92), (-105), 126, (-38), 122, 23, 102, (-108), (-95), 29, 61, (-16), (-34), (-77), 11, 114, (-89), 28, (-17), (-47), 83, 62, (-113), 51, 38, 95, (-20), 118, 42, 73, (-127), (-120), (-18), 33, (-60), 26, (-21), (-39), (-59), 57, (-103), (-51), (-83), 49, (-117), 1, 24, 35, (-35), 31, 78, 45, (-7), 72, 79, (-14), 101, (-114), 120, 92, 88, 25, (-115), (-27), (-104), 87, 103, 127, 5, 100, (-81), 99, (-74), (-2), (-11), (-73), 60, (-91), (-50), (-23), 104, 68, (-32), 77, 67, 105, 41, 46, (-84), 21, 89, (-88), 10, (-98), 110, 71, (-33), 52, 53, 106, (-49), (-36), 34, (-55), (-64), (-101), (-119), (-44), (-19), (-85), 18, (-94), 13, 82, (-69), 2, 47, (-87), (-41), 97, 30, (-76), 80, 4, (-10), (-62), 22, 37, (-122), 86, 85, 9, (-66), (-111)])]);
}

function $$init_3(this$static){
  this$static.gMDS0 = initDims_0('[I', [19], [(-1)], [256], 0);
  this$static.gMDS1 = initDims_0('[I', [19], [(-1)], [256], 0);
  this$static.gMDS2 = initDims_0('[I', [19], [(-1)], [256], 0);
  this$static.gMDS3 = initDims_0('[I', [19], [(-1)], [256], 0);
}

function $Bits32ToBytes_1(this$static, in_$, b, offset){
  b[offset] = narrow_byte(in_$);
  b[offset + 1] = narrow_byte(in_$ >> 8);
  b[offset + 2] = narrow_byte(in_$ >> 16);
  b[offset + 3] = narrow_byte(in_$ >> 24);
}

function $BytesTo32Bits(this$static, b, p){
  return b[p] & 255 | (b[p + 1] & 255) << 8 | (b[p + 2] & 255) << 16 | (b[p + 3] & 255) << 24;
}

function $F32(this$static, x, k32){
  var b0, b1, b2, b3, k0, k1, k2, k3, result;
  b0 = $b0(this$static, x);
  b1 = $b1(this$static, x);
  b2 = $b2(this$static, x);
  b3 = $b3(this$static, x);
  k0 = k32[0];
  k1 = k32[1];
  k2 = k32[2];
  k3 = k32[3];
  result = 0;
  switch (this$static.k64Cnt & 3) {
    case 1:
      result = this$static.gMDS0[P[0][b0] & 255 ^ $b0(this$static, k0)] ^ this$static.gMDS1[P[0][b1] & 255 ^ $b1(this$static, k0)] ^ this$static.gMDS2[P[1][b2] & 255 ^ $b2(this$static, k0)] ^ this$static.gMDS3[P[1][b3] & 255 ^ $b3(this$static, k0)];
      break;
    case 0:
      b0 = P[1][b0] & 255 ^ $b0(this$static, k3);
      b1 = P[0][b1] & 255 ^ $b1(this$static, k3);
      b2 = P[0][b2] & 255 ^ $b2(this$static, k3);
      b3 = P[1][b3] & 255 ^ $b3(this$static, k3);
    case 3:
      b0 = P[1][b0] & 255 ^ $b0(this$static, k2);
      b1 = P[1][b1] & 255 ^ $b1(this$static, k2);
      b2 = P[0][b2] & 255 ^ $b2(this$static, k2);
      b3 = P[0][b3] & 255 ^ $b3(this$static, k2);
    case 2:
      result = this$static.gMDS0[P[0][P[0][b0] & 255 ^ $b0(this$static, k1)] & 255 ^ $b0(this$static, k0)] ^ this$static.gMDS1[P[0][P[1][b1] & 255 ^ $b1(this$static, k1)] & 255 ^ $b1(this$static, k0)] ^ this$static.gMDS2[P[1][P[0][b2] & 255 ^ $b2(this$static, k1)] & 255 ^ $b2(this$static, k0)] ^ this$static.gMDS3[P[1][P[1][b3] & 255 ^ $b3(this$static, k1)] & 255 ^ $b3(this$static, k0)];
      break;
  }
  return result;
}

function $Fe32_0(this$static, x){
  return this$static.gSBox[0 + 2 * (x & 255)] ^ this$static.gSBox[1 + 2 * (x >>> 8 & 255)] ^ this$static.gSBox[512 + 2 * (x >>> 16 & 255)] ^ this$static.gSBox[513 + 2 * (x >>> 24 & 255)];
}

function $Fe32_3(this$static, x){
  return this$static.gSBox[0 + 2 * (x >>> 24 & 255)] ^ this$static.gSBox[1 + 2 * (x & 255)] ^ this$static.gSBox[512 + 2 * (x >>> 8 & 255)] ^ this$static.gSBox[513 + 2 * (x >>> 16 & 255)];
}

function $LFSR1(this$static, x){
  return x >> 1 ^ ((x & 1) != 0?180:0);
}

function $LFSR2(this$static, x){
  return x >> 2 ^ ((x & 2) != 0?180:0) ^ ((x & 1) != 0?90:0);
}

function $Mx_X(this$static, x){
  return x ^ $LFSR2(this$static, x);
}

function $Mx_Y(this$static, x){
  return x ^ $LFSR1(this$static, x) ^ $LFSR2(this$static, x);
}

function $RS_MDS_Encode(this$static, k0, k1){
  var i, r;
  r = k1;
  for (i = 0; i < 4; i++) {
    r = $RS_rem(this$static, r);
  }
  r ^= k0;
  for (i = 0; i < 4; i++) {
    r = $RS_rem(this$static, r);
  }
  return r;
}

function $RS_rem(this$static, x){
  var b, g2, g3;
  b = x >>> 24 & 255;
  g2 = (b << 1 ^ ((b & 128) != 0?333:0)) & 255;
  g3 = b >>> 1 ^ ((b & 1) != 0?166:0) ^ g2;
  return x << 8 ^ g3 << 24 ^ g2 << 16 ^ g3 << 8 ^ b;
}

function $TwofishEngine(this$static){
  var i, j, m1, mX, mY;
  $clinit_46();
  $$init_3(this$static);
  m1 = initDims_0('[I', [19], [(-1)], [2], 0);
  mX = initDims_0('[I', [19], [(-1)], [2], 0);
  mY = initDims_0('[I', [19], [(-1)], [2], 0);
  for (i = 0; i < 256; i++) {
    j = P[0][i] & 255;
    m1[0] = j;
    mX[0] = $Mx_X(this$static, j) & 255;
    mY[0] = $Mx_Y(this$static, j) & 255;
    j = P[1][i] & 255;
    m1[1] = j;
    mX[1] = $Mx_X(this$static, j) & 255;
    mY[1] = $Mx_Y(this$static, j) & 255;
    this$static.gMDS0[i] = m1[1] | mX[1] << 8 | mY[1] << 16 | mY[1] << 24;
    this$static.gMDS1[i] = mY[0] | mY[0] << 8 | mX[0] << 16 | m1[0] << 24;
    this$static.gMDS2[i] = mX[1] | mY[1] << 8 | m1[1] << 16 | mY[1] << 24;
    this$static.gMDS3[i] = mX[0] | m1[0] << 8 | mY[0] << 16 | mX[0] << 24;
  }
  return this$static;
}

function $b0(this$static, x){
  return x & 255;
}

function $b1(this$static, x){
  return x >>> 8 & 255;
}

function $b2(this$static, x){
  return x >>> 16 & 255;
}

function $b3(this$static, x){
  return x >>> 24 & 255;
}

function $decryptBlock_4(this$static, src, srcIndex, dst, dstIndex){
  var k, r, t0, t1, x0, x1, x2, x3;
  x2 = $BytesTo32Bits(this$static, src, srcIndex) ^ this$static.gSubKeys[4];
  x3 = $BytesTo32Bits(this$static, src, srcIndex + 4) ^ this$static.gSubKeys[5];
  x0 = $BytesTo32Bits(this$static, src, srcIndex + 8) ^ this$static.gSubKeys[6];
  x1 = $BytesTo32Bits(this$static, src, srcIndex + 12) ^ this$static.gSubKeys[7];
  k = 39;
  for (r = 0; r < 16; r += 2) {
    t0 = $Fe32_0(this$static, x2);
    t1 = $Fe32_3(this$static, x3);
    x1 ^= t0 + 2 * t1 + this$static.gSubKeys[k--];
    x0 = (x0 << 1 | x0 >>> 31) ^ t0 + t1 + this$static.gSubKeys[k--];
    x1 = x1 >>> 1 | x1 << 31;
    t0 = $Fe32_0(this$static, x0);
    t1 = $Fe32_3(this$static, x1);
    x3 ^= t0 + 2 * t1 + this$static.gSubKeys[k--];
    x2 = (x2 << 1 | x2 >>> 31) ^ t0 + t1 + this$static.gSubKeys[k--];
    x3 = x3 >>> 1 | x3 << 31;
  }
  $Bits32ToBytes_1(this$static, x0 ^ this$static.gSubKeys[0], dst, dstIndex);
  $Bits32ToBytes_1(this$static, x1 ^ this$static.gSubKeys[1], dst, dstIndex + 4);
  $Bits32ToBytes_1(this$static, x2 ^ this$static.gSubKeys[2], dst, dstIndex + 8);
  $Bits32ToBytes_1(this$static, x3 ^ this$static.gSubKeys[3], dst, dstIndex + 12);
}

function $encryptBlock_4(this$static, src, srcIndex, dst, dstIndex){
  var k, r, t0, t1, x0, x1, x2, x3;
  x0 = $BytesTo32Bits(this$static, src, srcIndex) ^ this$static.gSubKeys[0];
  x1 = $BytesTo32Bits(this$static, src, srcIndex + 4) ^ this$static.gSubKeys[1];
  x2 = $BytesTo32Bits(this$static, src, srcIndex + 8) ^ this$static.gSubKeys[2];
  x3 = $BytesTo32Bits(this$static, src, srcIndex + 12) ^ this$static.gSubKeys[3];
  k = 8;
  for (r = 0; r < 16; r += 2) {
    t0 = $Fe32_0(this$static, x0);
    t1 = $Fe32_3(this$static, x1);
    x2 ^= t0 + t1 + this$static.gSubKeys[k++];
    x2 = x2 >>> 1 | x2 << 31;
    x3 = (x3 << 1 | x3 >>> 31) ^ t0 + 2 * t1 + this$static.gSubKeys[k++];
    t0 = $Fe32_0(this$static, x2);
    t1 = $Fe32_3(this$static, x3);
    x0 ^= t0 + t1 + this$static.gSubKeys[k++];
    x0 = x0 >>> 1 | x0 << 31;
    x1 = (x1 << 1 | x1 >>> 31) ^ t0 + 2 * t1 + this$static.gSubKeys[k++];
  }
  $Bits32ToBytes_1(this$static, x2 ^ this$static.gSubKeys[4], dst, dstIndex);
  $Bits32ToBytes_1(this$static, x3 ^ this$static.gSubKeys[5], dst, dstIndex + 4);
  $Bits32ToBytes_1(this$static, x0 ^ this$static.gSubKeys[6], dst, dstIndex + 8);
  $Bits32ToBytes_1(this$static, x1 ^ this$static.gSubKeys[7], dst, dstIndex + 12);
}

function $setKey_1(this$static, key){
  var A, B, b0, b1, b2, b3, i, k0, k1, k2, k3, k32e, k32o, p, q, sBoxKeys;
  k32e = initDims_0('[I', [19], [(-1)], [4], 0);
  k32o = initDims_0('[I', [19], [(-1)], [4], 0);
  sBoxKeys = initDims_0('[I', [19], [(-1)], [4], 0);
  this$static.gSubKeys = initDims_0('[I', [19], [(-1)], [40], 0);
  if (this$static.k64Cnt < 1) {
    throw $IllegalArgumentException(new IllegalArgumentException(), 'Key size less than 64 bits');
  }
  if (this$static.k64Cnt > 4) {
    throw $IllegalArgumentException(new IllegalArgumentException(), 'Key size larger than 256 bits');
  }
  for (i = 0; i < this$static.k64Cnt; i++) {
    p = i * 8;
    k32e[i] = $BytesTo32Bits(this$static, key, p);
    k32o[i] = $BytesTo32Bits(this$static, key, p + 4);
    sBoxKeys[this$static.k64Cnt - 1 - i] = $RS_MDS_Encode(this$static, k32e[i], k32o[i]);
  }
  for (i = 0; i < 20; i++) {
    q = i * 33686018;
    A = $F32(this$static, q, k32e);
    B = $F32(this$static, q + 16843009, k32o);
    B = B << 8 | B >>> 24;
    A += B;
    this$static.gSubKeys[i * 2] = A;
    A += B;
    this$static.gSubKeys[i * 2 + 1] = A << 9 | A >>> 23;
  }
  k0 = sBoxKeys[0];
  k1 = sBoxKeys[1];
  k2 = sBoxKeys[2];
  k3 = sBoxKeys[3];
  this$static.gSBox = initDims_0('[I', [19], [(-1)], [1024], 0);
  for (i = 0; i < 256; i++) {
    b0 = b1 = b2 = b3 = i;
    switch (this$static.k64Cnt & 3) {
      case 1:
        this$static.gSBox[i * 2] = this$static.gMDS0[P[0][b0] & 255 ^ $b0(this$static, k0)];
        this$static.gSBox[i * 2 + 1] = this$static.gMDS1[P[0][b1] & 255 ^ $b1(this$static, k0)];
        this$static.gSBox[i * 2 + 512] = this$static.gMDS2[P[1][b2] & 255 ^ $b2(this$static, k0)];
        this$static.gSBox[i * 2 + 513] = this$static.gMDS3[P[1][b3] & 255 ^ $b3(this$static, k0)];
        break;
      case 0:
        b0 = P[1][b0] & 255 ^ $b0(this$static, k3);
        b1 = P[0][b1] & 255 ^ $b1(this$static, k3);
        b2 = P[0][b2] & 255 ^ $b2(this$static, k3);
        b3 = P[1][b3] & 255 ^ $b3(this$static, k3);
      case 3:
        b0 = P[1][b0] & 255 ^ $b0(this$static, k2);
        b1 = P[1][b1] & 255 ^ $b1(this$static, k2);
        b2 = P[0][b2] & 255 ^ $b2(this$static, k2);
        b3 = P[0][b3] & 255 ^ $b3(this$static, k2);
      case 2:
        this$static.gSBox[i * 2] = this$static.gMDS0[P[0][P[0][b0] & 255 ^ $b0(this$static, k1)] & 255 ^ $b0(this$static, k0)];
        this$static.gSBox[i * 2 + 1] = this$static.gMDS1[P[0][P[1][b1] & 255 ^ $b1(this$static, k1)] & 255 ^ $b1(this$static, k0)];
        this$static.gSBox[i * 2 + 512] = this$static.gMDS2[P[1][P[0][b2] & 255 ^ $b2(this$static, k1)] & 255 ^ $b2(this$static, k0)];
        this$static.gSBox[i * 2 + 513] = this$static.gMDS3[P[1][P[1][b3] & 255 ^ $b3(this$static, k1)] & 255 ^ $b3(this$static, k0)];
        break;
    }
  }
}

function getBlockSize_6(){
  return 16;
}

function init_7(encrypting, params){
  if (instanceOf(params, 5)) {
    this.encrypting = encrypting;
    this.workingKey = dynamicCast(params, 5).getKey();
    this.k64Cnt = round_int(this.workingKey.length_0 / 8);
    $setKey_1(this, this.workingKey);
    return;
  }
  throw $IllegalArgumentException(new IllegalArgumentException(), 'invalid parameter passed to Twofish init - ');
}

function processBlock_6(in_$, inOff, out, outOff){
  if (this.workingKey === null) {
    throw $IllegalStateException(new IllegalStateException(), 'Twofish not initialised');
  }
  if (inOff + 16 > in_$.length_0) {
    throw $DataLengthException(new DataLengthException(), 'input buffer too short');
  }
  if (outOff + 16 > out.length_0) {
    throw $DataLengthException(new DataLengthException(), 'output buffer too short');
  }
  if (this.encrypting) {
    $encryptBlock_4(this, in_$, inOff, out, outOff);
  }
   else {
    $decryptBlock_4(this, in_$, inOff, out, outOff);
  }
  return 16;
}

function reset_6(){
  if (this.workingKey !== null) {
    $setKey_1(this, this.workingKey);
  }
}

function TwofishEngine(){
}

_ = TwofishEngine.prototype = new Object_0();
_.getBlockSize = getBlockSize_6;
_.init = init_7;
_.processBlock = processBlock_6;
_.reset = reset_6;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_bc_ + 'TwofishEngine';
_.typeId$ = 0;
_.encrypting = false;
_.gSBox = null;
_.gSubKeys = null;
_.k64Cnt = 0;
_.workingKey = null;
var P;
function $adler32(this$static, adler, buf, index, len){
  var k, s1, s2;
  if (buf === null) {
    return 1;
  }
  s1 = adler & 65535;
  s2 = adler >> 16 & 65535;
  while (len > 0) {
    k = len < 5552?len:5552;
    len -= k;
    while (k >= 16) {
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      s1 += buf[index++] & 255;
      s2 += s1;
      k -= 16;
    }
    if (k != 0) {
      do {
        s1 += buf[index++] & 255;
        s2 += s1;
      }
       while (--k != 0);
    }
    s1 %= 65521;
    s2 %= 65521;
  }
  return s2 << 16 | s1;
}

function Adler32(){
}

_ = Adler32.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'Adler32';
_.typeId$ = 0;
function $clinit_49(){
  $clinit_49 = nullMethod;
  {
    config_table = initDims_0('[Lorg.emergent.lucidity.lucifer.client.jzlib.Deflate$Config;', [0], [0], [10], null);
    config_table[0] = $Deflate$Config(new Deflate$Config(), 0, 0, 0, 0, 0);
    config_table[1] = $Deflate$Config(new Deflate$Config(), 4, 4, 8, 4, 1);
    config_table[2] = $Deflate$Config(new Deflate$Config(), 4, 5, 16, 8, 1);
    config_table[3] = $Deflate$Config(new Deflate$Config(), 4, 6, 32, 32, 1);
    config_table[4] = $Deflate$Config(new Deflate$Config(), 4, 4, 16, 16, 2);
    config_table[5] = $Deflate$Config(new Deflate$Config(), 8, 16, 32, 32, 2);
    config_table[6] = $Deflate$Config(new Deflate$Config(), 8, 16, 128, 128, 2);
    config_table[7] = $Deflate$Config(new Deflate$Config(), 8, 32, 128, 256, 2);
    config_table[8] = $Deflate$Config(new Deflate$Config(), 32, 128, 258, 1024, 2);
    config_table[9] = $Deflate$Config(new Deflate$Config(), 32, 258, 258, 4096, 2);
  }
  z_errmsg = initValues('[Ljava.lang.String;', 0, 1, ['need dictionary', 'stream end', '', 'file error', 'stream error', 'data error', 'insufficient memory', 'buffer error', 'incompatible version', '']);
}

function $$init_4(this$static){
  this$static.l_desc = $Tree(new Tree());
  this$static.d_desc = $Tree(new Tree());
  this$static.bl_desc = $Tree(new Tree());
  this$static.bl_count = initDims_0('[S', [0], [(-1)], [16], 0);
  this$static.heap = initDims_0('[I', [19], [(-1)], [573], 0);
  this$static.depth = initDims_0('[B', [0], [(-1)], [573], 0);
}

function $Deflate(this$static){
  $clinit_49();
  $$init_4(this$static);
  this$static.dyn_ltree = initDims_0('[S', [0], [(-1)], [1146], 0);
  this$static.dyn_dtree = initDims_0('[S', [0], [(-1)], [122], 0);
  this$static.bl_tree = initDims_0('[S', [0], [(-1)], [78], 0);
  return this$static;
}

function $_tr_align(this$static){
  $send_bits(this$static, 2, 3);
  $send_code(this$static, 256, ($clinit_54() , static_ltree));
  $bi_flush(this$static);
  if (1 + this$static.last_eob_len + 10 - this$static.bi_valid < 9) {
    $send_bits(this$static, 2, 3);
    $send_code(this$static, 256, ($clinit_54() , static_ltree));
    $bi_flush(this$static);
  }
  this$static.last_eob_len = 7;
}

function $_tr_flush_block(this$static, buf, stored_len, eof){
  var max_blindex, opt_lenb, static_lenb;
  max_blindex = 0;
  if (this$static.level > 0) {
    if (this$static.data_type == 2)
      $set_data_type(this$static);
    $build_tree(this$static.l_desc, this$static);
    $build_tree(this$static.d_desc, this$static);
    max_blindex = $build_bl_tree(this$static);
    opt_lenb = this$static.opt_len + 3 + 7 >>> 3;
    static_lenb = this$static.static_len + 3 + 7 >>> 3;
    if (static_lenb <= opt_lenb)
      opt_lenb = static_lenb;
  }
   else {
    opt_lenb = static_lenb = stored_len + 5;
  }
  if (stored_len + 4 <= opt_lenb && buf != (-1)) {
    $_tr_stored_block(this$static, buf, stored_len, eof);
  }
   else if (static_lenb == opt_lenb) {
    $send_bits(this$static, 2 + (eof?1:0), 3);
    $compress_block(this$static, ($clinit_54() , static_ltree), ($clinit_54() , static_dtree));
  }
   else {
    $send_bits(this$static, 4 + (eof?1:0), 3);
    $send_all_trees(this$static, this$static.l_desc.max_code + 1, this$static.d_desc.max_code + 1, max_blindex + 1);
    $compress_block(this$static, this$static.dyn_ltree, this$static.dyn_dtree);
  }
  $init_block(this$static);
  if (eof) {
    $bi_windup(this$static);
  }
}

function $_tr_stored_block(this$static, buf, stored_len, eof){
  $send_bits(this$static, 0 + (eof?1:0), 3);
  $copy_block(this$static, buf, stored_len, true);
}

function $_tr_tally(this$static, dist, lc){
  var dcode, in_length, out_length;
  this$static.pending_buf[this$static.d_buf + this$static.last_lit * 2] = narrow_byte(dist >>> 8);
  this$static.pending_buf[this$static.d_buf + this$static.last_lit * 2 + 1] = narrow_byte(dist);
  this$static.pending_buf[this$static.l_buf + this$static.last_lit] = narrow_byte(lc);
  this$static.last_lit++;
  if (dist == 0) {
    this$static.dyn_ltree[lc * 2]++;
  }
   else {
    this$static.matches++;
    dist--;
    this$static.dyn_ltree[(($clinit_55() , _length_code)[lc] + 256 + 1) * 2]++;
    this$static.dyn_dtree[d_code(dist) * 2]++;
  }
  if ((this$static.last_lit & 8191) == 0 && this$static.level > 2) {
    out_length = this$static.last_lit * 8;
    in_length = this$static.strstart - this$static.block_start;
    for (dcode = 0; dcode < 30; dcode++) {
      out_length += this$static.dyn_dtree[dcode * 2] * (5 + ($clinit_55() , extra_dbits)[dcode]);
    }
    out_length >>>= 3;
    if (this$static.matches < round_int(this$static.last_lit / 2) && out_length < round_int(in_length / 2))
      return true;
  }
  return this$static.last_lit == this$static.lit_bufsize - 1;
}

function $bi_flush(this$static){
  if (this$static.bi_valid == 16) {
    $put_short(this$static, this$static.bi_buf);
    this$static.bi_buf = 0;
    this$static.bi_valid = 0;
  }
   else if (this$static.bi_valid >= 8) {
    $put_byte(this$static, narrow_byte(this$static.bi_buf));
    this$static.bi_buf >>>= 8;
    this$static.bi_valid -= 8;
  }
}

function $bi_windup(this$static){
  if (this$static.bi_valid > 8) {
    $put_short(this$static, this$static.bi_buf);
  }
   else if (this$static.bi_valid > 0) {
    $put_byte(this$static, narrow_byte(this$static.bi_buf));
  }
  this$static.bi_buf = 0;
  this$static.bi_valid = 0;
}

function $build_bl_tree(this$static){
  var max_blindex;
  $scan_tree(this$static, this$static.dyn_ltree, this$static.l_desc.max_code);
  $scan_tree(this$static, this$static.dyn_dtree, this$static.d_desc.max_code);
  $build_tree(this$static.bl_desc, this$static);
  for (max_blindex = 18; max_blindex >= 3; max_blindex--) {
    if (this$static.bl_tree[($clinit_55() , bl_order)[max_blindex] * 2 + 1] != 0)
      break;
  }
  this$static.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4;
  return max_blindex;
}

function $compress_block(this$static, ltree, dtree){
  var code, dist, extra, lc, lx;
  lx = 0;
  if (this$static.last_lit != 0) {
    do {
      dist = this$static.pending_buf[this$static.d_buf + lx * 2] << 8 & 65280 | this$static.pending_buf[this$static.d_buf + lx * 2 + 1] & 255;
      lc = this$static.pending_buf[this$static.l_buf + lx] & 255;
      lx++;
      if (dist == 0) {
        $send_code(this$static, lc, ltree);
      }
       else {
        code = ($clinit_55() , _length_code)[lc];
        $send_code(this$static, code + 256 + 1, ltree);
        extra = ($clinit_55() , extra_lbits)[code];
        if (extra != 0) {
          lc -= ($clinit_55() , base_length)[code];
          $send_bits(this$static, lc, extra);
        }
        dist--;
        code = d_code(dist);
        $send_code(this$static, code, dtree);
        extra = ($clinit_55() , extra_dbits)[code];
        if (extra != 0) {
          dist -= ($clinit_55() , base_dist)[code];
          $send_bits(this$static, dist, extra);
        }
      }
    }
     while (lx < this$static.last_lit);
  }
  $send_code(this$static, 256, ltree);
  this$static.last_eob_len = ltree[513];
}

function $copy_block(this$static, buf, len, header){
  var index;
  index = 0;
  $bi_windup(this$static);
  this$static.last_eob_len = 8;
  if (header) {
    $put_short(this$static, narrow_short(len));
    $put_short(this$static, narrow_short(~len));
  }
  $put_byte_0(this$static, this$static.window_0, buf, len);
}

function $deflate(this$static, strm, flush){
  var bstate, header, i, level_flags, old_flush;
  if (flush > 4 || flush < 0) {
    return (-2);
  }
  if (strm.next_out === null || strm.next_in === null && strm.avail_in != 0 || this$static.status == 666 && flush != 4) {
    strm.msg = z_errmsg[4];
    return (-2);
  }
  if (strm.avail_out == 0) {
    strm.msg = z_errmsg[7];
    return (-5);
  }
  this$static.strm = strm;
  old_flush = this$static.last_flush;
  this$static.last_flush = flush;
  if (this$static.status == 42) {
    header = 8 + (this$static.w_bits - 8 << 4) << 8;
    level_flags = (this$static.level - 1 & 255) >> 1;
    if (level_flags > 3)
      level_flags = 3;
    header |= level_flags << 6;
    if (this$static.strstart != 0)
      header |= 32;
    header += 31 - header % 31;
    this$static.status = 113;
    $putShortMSB(this$static, header);
    if (this$static.strstart != 0) {
      $putShortMSB(this$static, narrow_int(strm.adler >>> 16));
      $putShortMSB(this$static, narrow_int(strm.adler & 65535));
    }
    strm.adler = $adler32(strm._adler, 0, null, 0, 0);
  }
  if (this$static.pending != 0) {
    $flush_pending(strm);
    if (strm.avail_out == 0) {
      this$static.last_flush = (-1);
      return 0;
    }
  }
   else if (strm.avail_in == 0 && flush <= old_flush && flush != 4) {
    strm.msg = z_errmsg[7];
    return (-5);
  }
  if (this$static.status == 666 && strm.avail_in != 0) {
    strm.msg = z_errmsg[7];
    return (-5);
  }
  if (strm.avail_in != 0 || this$static.lookahead != 0 || flush != 0 && this$static.status != 666) {
    bstate = (-1);
    switch (config_table[this$static.level].func) {
      case 0:
        bstate = $deflate_stored(this$static, flush);
        break;
      case 1:
        bstate = $deflate_fast(this$static, flush);
        break;
      case 2:
        bstate = $deflate_slow(this$static, flush);
        break;
      default:}
    if (bstate == 2 || bstate == 3) {
      this$static.status = 666;
    }
    if (bstate == 0 || bstate == 2) {
      if (strm.avail_out == 0) {
        this$static.last_flush = (-1);
      }
      return 0;
    }
    if (bstate == 1) {
      if (flush == 1) {
        $_tr_align(this$static);
      }
       else {
        $_tr_stored_block(this$static, 0, 0, false);
        if (flush == 3) {
          for (i = 0; i < this$static.hash_size; i++)
            this$static.head[i] = 0;
        }
      }
      $flush_pending(strm);
      if (strm.avail_out == 0) {
        this$static.last_flush = (-1);
        return 0;
      }
    }
  }
  if (flush != 4)
    return 0;
  if (this$static.noheader != 0)
    return 1;
  $putShortMSB(this$static, narrow_int(strm.adler >>> 16));
  $putShortMSB(this$static, narrow_int(strm.adler & 65535));
  $flush_pending(strm);
  this$static.noheader = (-1);
  return this$static.pending != 0?0:1;
}

function $deflateEnd(this$static){
  if (this$static.status != 42 && this$static.status != 113 && this$static.status != 666) {
    return (-2);
  }
  this$static.pending_buf = null;
  this$static.head = null;
  this$static.prev = null;
  this$static.window_0 = null;
  return this$static.status == 113?(-3):0;
}

function $deflateInit(this$static, strm, level, bits){
  return $deflateInit2(this$static, strm, level, 8, bits, 8, 0);
}

function $deflateInit2(this$static, strm, level, method, windowBits, memLevel, strategy){
  var noheader;
  noheader = 0;
  strm.msg = null;
  if (level == (-1))
    level = 6;
  if (windowBits < 0) {
    noheader = 1;
    windowBits = -windowBits;
  }
  if (memLevel < 1 || memLevel > 9 || method != 8 || windowBits < 9 || windowBits > 15 || level < 0 || level > 9 || strategy < 0 || strategy > 2) {
    return (-2);
  }
  strm.dstate = this$static;
  this$static.noheader = noheader;
  this$static.w_bits = windowBits;
  this$static.w_size = 1 << this$static.w_bits;
  this$static.w_mask = this$static.w_size - 1;
  this$static.hash_bits = memLevel + 7;
  this$static.hash_size = 1 << this$static.hash_bits;
  this$static.hash_mask = this$static.hash_size - 1;
  this$static.hash_shift = round_int((this$static.hash_bits + 3 - 1) / 3);
  this$static.window_0 = initDims_0('[B', [0], [(-1)], [this$static.w_size * 2], 0);
  this$static.prev = initDims_0('[S', [0], [(-1)], [this$static.w_size], 0);
  this$static.head = initDims_0('[S', [0], [(-1)], [this$static.hash_size], 0);
  this$static.lit_bufsize = 1 << memLevel + 6;
  this$static.pending_buf = initDims_0('[B', [0], [(-1)], [this$static.lit_bufsize * 4], 0);
  this$static.pending_buf_size = this$static.lit_bufsize * 4;
  this$static.d_buf = round_int(this$static.lit_bufsize / 2);
  this$static.l_buf = 3 * this$static.lit_bufsize;
  this$static.level = level;
  this$static.strategy = strategy;
  narrow_byte(method);
  return $deflateReset(this$static, strm);
}

function $deflateReset(this$static, strm){
  strm.total_in = strm.total_out = 0;
  strm.msg = null;
  strm.data_type = 2;
  this$static.pending = 0;
  this$static.pending_out = 0;
  if (this$static.noheader < 0) {
    this$static.noheader = 0;
  }
  this$static.status = this$static.noheader != 0?113:42;
  strm.adler = $adler32(strm._adler, 0, null, 0, 0);
  this$static.last_flush = 0;
  $tr_init(this$static);
  $lm_init(this$static);
  return 0;
}

function $deflate_fast(this$static, flush){
  var bflush, hash_head;
  hash_head = 0;
  while (true) {
    if (this$static.lookahead < 262) {
      $fill_window(this$static);
      if (this$static.lookahead < 262 && flush == 0) {
        return 0;
      }
      if (this$static.lookahead == 0)
        break;
    }
    if (this$static.lookahead >= 3) {
      this$static.ins_h = (this$static.ins_h << this$static.hash_shift ^ this$static.window_0[this$static.strstart + 2] & 255) & this$static.hash_mask;
      hash_head = this$static.head[this$static.ins_h] & 65535;
      this$static.prev[this$static.strstart & this$static.w_mask] = this$static.head[this$static.ins_h];
      this$static.head[this$static.ins_h] = narrow_short(this$static.strstart);
    }
    if (hash_head != 0 && (this$static.strstart - hash_head & 65535) <= this$static.w_size - 262) {
      if (this$static.strategy != 2) {
        this$static.match_length = $longest_match(this$static, hash_head);
      }
    }
    if (this$static.match_length >= 3) {
      bflush = $_tr_tally(this$static, this$static.strstart - this$static.match_start, this$static.match_length - 3);
      this$static.lookahead -= this$static.match_length;
      if (this$static.match_length <= this$static.max_lazy_match && this$static.lookahead >= 3) {
        this$static.match_length--;
        do {
          this$static.strstart++;
          this$static.ins_h = (this$static.ins_h << this$static.hash_shift ^ this$static.window_0[this$static.strstart + 2] & 255) & this$static.hash_mask;
          hash_head = this$static.head[this$static.ins_h] & 65535;
          this$static.prev[this$static.strstart & this$static.w_mask] = this$static.head[this$static.ins_h];
          this$static.head[this$static.ins_h] = narrow_short(this$static.strstart);
        }
         while (--this$static.match_length != 0);
        this$static.strstart++;
      }
       else {
        this$static.strstart += this$static.match_length;
        this$static.match_length = 0;
        this$static.ins_h = this$static.window_0[this$static.strstart] & 255;
        this$static.ins_h = (this$static.ins_h << this$static.hash_shift ^ this$static.window_0[this$static.strstart + 1] & 255) & this$static.hash_mask;
      }
    }
     else {
      bflush = $_tr_tally(this$static, 0, this$static.window_0[this$static.strstart] & 255);
      this$static.lookahead--;
      this$static.strstart++;
    }
    if (bflush) {
      $flush_block_only(this$static, false);
      if (this$static.strm.avail_out == 0)
        return 0;
    }
  }
  $flush_block_only(this$static, flush == 4);
  if (this$static.strm.avail_out == 0) {
    if (flush == 4)
      return 2;
    else 
      return 0;
  }
  return flush == 4?3:1;
}

function $deflate_slow(this$static, flush){
  var bflush, hash_head, max_insert;
  hash_head = 0;
  while (true) {
    if (this$static.lookahead < 262) {
      $fill_window(this$static);
      if (this$static.lookahead < 262 && flush == 0) {
        return 0;
      }
      if (this$static.lookahead == 0)
        break;
    }
    if (this$static.lookahead >= 3) {
      this$static.ins_h = (this$static.ins_h << this$static.hash_shift ^ this$static.window_0[this$static.strstart + 2] & 255) & this$static.hash_mask;
      hash_head = this$static.head[this$static.ins_h] & 65535;
      this$static.prev[this$static.strstart & this$static.w_mask] = this$static.head[this$static.ins_h];
      this$static.head[this$static.ins_h] = narrow_short(this$static.strstart);
    }
    this$static.prev_length = this$static.match_length;
    this$static.prev_match = this$static.match_start;
    this$static.match_length = 2;
    if (hash_head != 0 && this$static.prev_length < this$static.max_lazy_match && (this$static.strstart - hash_head & 65535) <= this$static.w_size - 262) {
      if (this$static.strategy != 2) {
        this$static.match_length = $longest_match(this$static, hash_head);
      }
      if (this$static.match_length <= 5 && (this$static.strategy == 1 || this$static.match_length == 3 && this$static.strstart - this$static.match_start > 4096)) {
        this$static.match_length = 2;
      }
    }
    if (this$static.prev_length >= 3 && this$static.match_length <= this$static.prev_length) {
      max_insert = this$static.strstart + this$static.lookahead - 3;
      bflush = $_tr_tally(this$static, this$static.strstart - 1 - this$static.prev_match, this$static.prev_length - 3);
      this$static.lookahead -= this$static.prev_length - 1;
      this$static.prev_length -= 2;
      do {
        if (++this$static.strstart <= max_insert) {
          this$static.ins_h = (this$static.ins_h << this$static.hash_shift ^ this$static.window_0[this$static.strstart + 2] & 255) & this$static.hash_mask;
          hash_head = this$static.head[this$static.ins_h] & 65535;
          this$static.prev[this$static.strstart & this$static.w_mask] = this$static.head[this$static.ins_h];
          this$static.head[this$static.ins_h] = narrow_short(this$static.strstart);
        }
      }
       while (--this$static.prev_length != 0);
      this$static.match_available = 0;
      this$static.match_length = 2;
      this$static.strstart++;
      if (bflush) {
        $flush_block_only(this$static, false);
        if (this$static.strm.avail_out == 0)
          return 0;
      }
    }
     else if (this$static.match_available != 0) {
      bflush = $_tr_tally(this$static, 0, this$static.window_0[this$static.strstart - 1] & 255);
      if (bflush) {
        $flush_block_only(this$static, false);
      }
      this$static.strstart++;
      this$static.lookahead--;
      if (this$static.strm.avail_out == 0)
        return 0;
    }
     else {
      this$static.match_available = 1;
      this$static.strstart++;
      this$static.lookahead--;
    }
  }
  if (this$static.match_available != 0) {
    bflush = $_tr_tally(this$static, 0, this$static.window_0[this$static.strstart - 1] & 255);
    this$static.match_available = 0;
  }
  $flush_block_only(this$static, flush == 4);
  if (this$static.strm.avail_out == 0) {
    if (flush == 4)
      return 2;
    else 
      return 0;
  }
  return flush == 4?3:1;
}

function $deflate_stored(this$static, flush){
  var max_block_size, max_start;
  max_block_size = 65535;
  if (max_block_size > this$static.pending_buf_size - 5) {
    max_block_size = this$static.pending_buf_size - 5;
  }
  while (true) {
    if (this$static.lookahead <= 1) {
      $fill_window(this$static);
      if (this$static.lookahead == 0 && flush == 0)
        return 0;
      if (this$static.lookahead == 0)
        break;
    }
    this$static.strstart += this$static.lookahead;
    this$static.lookahead = 0;
    max_start = this$static.block_start + max_block_size;
    if (this$static.strstart == 0 || this$static.strstart >= max_start) {
      this$static.lookahead = this$static.strstart - max_start;
      this$static.strstart = max_start;
      $flush_block_only(this$static, false);
      if (this$static.strm.avail_out == 0)
        return 0;
    }
    if (this$static.strstart - this$static.block_start >= this$static.w_size - 262) {
      $flush_block_only(this$static, false);
      if (this$static.strm.avail_out == 0)
        return 0;
    }
  }
  $flush_block_only(this$static, flush == 4);
  if (this$static.strm.avail_out == 0)
    return flush == 4?2:0;
  return flush == 4?3:1;
}

function $fill_window(this$static){
  var m, more, n, p;
  do {
    more = this$static.window_size - this$static.lookahead - this$static.strstart;
    if (more == 0 && this$static.strstart == 0 && this$static.lookahead == 0) {
      more = this$static.w_size;
    }
     else if (more == (-1)) {
      more--;
    }
     else if (this$static.strstart >= this$static.w_size + this$static.w_size - 262) {
      arraycopy(this$static.window_0, this$static.w_size, this$static.window_0, 0, this$static.w_size);
      this$static.match_start -= this$static.w_size;
      this$static.strstart -= this$static.w_size;
      this$static.block_start -= this$static.w_size;
      n = this$static.hash_size;
      p = n;
      do {
        m = this$static.head[--p] & 65535;
        this$static.head[p] = m >= this$static.w_size?narrow_short(m - this$static.w_size):0;
      }
       while (--n != 0);
      n = this$static.w_size;
      p = n;
      do {
        m = this$static.prev[--p] & 65535;
        this$static.prev[p] = m >= this$static.w_size?narrow_short(m - this$static.w_size):0;
      }
       while (--n != 0);
      more += this$static.w_size;
    }
    if (this$static.strm.avail_in == 0)
      return;
    n = $read_buf(this$static.strm, this$static.window_0, this$static.strstart + this$static.lookahead, more);
    this$static.lookahead += n;
    if (this$static.lookahead >= 3) {
      this$static.ins_h = this$static.window_0[this$static.strstart] & 255;
      this$static.ins_h = (this$static.ins_h << this$static.hash_shift ^ this$static.window_0[this$static.strstart + 1] & 255) & this$static.hash_mask;
    }
  }
   while (this$static.lookahead < 262 && this$static.strm.avail_in != 0);
}

function $flush_block_only(this$static, eof){
  $_tr_flush_block(this$static, this$static.block_start >= 0?this$static.block_start:(-1), this$static.strstart - this$static.block_start, eof);
  this$static.block_start = this$static.strstart;
  $flush_pending(this$static.strm);
}

function $init_block(this$static){
  var i;
  for (i = 0; i < 286; i++)
    this$static.dyn_ltree[i * 2] = 0;
  for (i = 0; i < 30; i++)
    this$static.dyn_dtree[i * 2] = 0;
  for (i = 0; i < 19; i++)
    this$static.bl_tree[i * 2] = 0;
  this$static.dyn_ltree[512] = 1;
  this$static.opt_len = this$static.static_len = 0;
  this$static.last_lit = this$static.matches = 0;
}

function $lm_init(this$static){
  var i;
  this$static.window_size = 2 * this$static.w_size;
  this$static.head[this$static.hash_size - 1] = 0;
  for (i = 0; i < this$static.hash_size - 1; i++) {
    this$static.head[i] = 0;
  }
  this$static.max_lazy_match = config_table[this$static.level].max_lazy;
  this$static.good_match = config_table[this$static.level].good_length;
  this$static.nice_match = config_table[this$static.level].nice_length;
  this$static.max_chain_length = config_table[this$static.level].max_chain;
  this$static.strstart = 0;
  this$static.block_start = 0;
  this$static.lookahead = 0;
  this$static.match_length = this$static.prev_length = 2;
  this$static.match_available = 0;
  this$static.ins_h = 0;
}

function $longest_match(this$static, cur_match){
  var best_len, chain_length, len, limit, match, nice_match, scan, scan_end, scan_end1, strend, wmask;
  chain_length = this$static.max_chain_length;
  scan = this$static.strstart;
  best_len = this$static.prev_length;
  limit = this$static.strstart > this$static.w_size - 262?this$static.strstart - (this$static.w_size - 262):0;
  nice_match = this$static.nice_match;
  wmask = this$static.w_mask;
  strend = this$static.strstart + 258;
  scan_end1 = this$static.window_0[scan + best_len - 1];
  scan_end = this$static.window_0[scan + best_len];
  if (this$static.prev_length >= this$static.good_match) {
    chain_length >>= 2;
  }
  if (nice_match > this$static.lookahead)
    nice_match = this$static.lookahead;
  do {
    match = cur_match;
    if (this$static.window_0[match + best_len] != scan_end || this$static.window_0[match + best_len - 1] != scan_end1 || this$static.window_0[match] != this$static.window_0[scan] || this$static.window_0[++match] != this$static.window_0[scan + 1])
      continue;
    scan += 2;
    match++;
    do {
    }
     while (this$static.window_0[++scan] == this$static.window_0[++match] && this$static.window_0[++scan] == this$static.window_0[++match] && this$static.window_0[++scan] == this$static.window_0[++match] && this$static.window_0[++scan] == this$static.window_0[++match] && this$static.window_0[++scan] == this$static.window_0[++match] && this$static.window_0[++scan] == this$static.window_0[++match] && this$static.window_0[++scan] == this$static.window_0[++match] && this$static.window_0[++scan] == this$static.window_0[++match] && scan < strend);
    len = 258 - (strend - scan);
    scan = strend - 258;
    if (len > best_len) {
      this$static.match_start = cur_match;
      best_len = len;
      if (len >= nice_match)
        break;
      scan_end1 = this$static.window_0[scan + best_len - 1];
      scan_end = this$static.window_0[scan + best_len];
    }
  }
   while ((cur_match = this$static.prev[cur_match & wmask] & 65535) > limit && --chain_length != 0);
  if (best_len <= this$static.lookahead)
    return best_len;
  return this$static.lookahead;
}

function $pqdownheap(this$static, tree, k){
  var j, v;
  v = this$static.heap[k];
  j = k << 1;
  while (j <= this$static.heap_len) {
    if (j < this$static.heap_len && smaller(tree, this$static.heap[j + 1], this$static.heap[j], this$static.depth)) {
      j++;
    }
    if (smaller(tree, v, this$static.heap[j], this$static.depth))
      break;
    this$static.heap[k] = this$static.heap[j];
    k = j;
    j <<= 1;
  }
  this$static.heap[k] = v;
}

function $putShortMSB(this$static, b){
  $put_byte(this$static, narrow_byte(b >> 8));
  $put_byte(this$static, narrow_byte(b));
}

function $put_byte_0(this$static, p, start, len){
  arraycopy(p, start, this$static.pending_buf, this$static.pending, len);
  this$static.pending += len;
}

function $put_byte(this$static, c){
  this$static.pending_buf[this$static.pending++] = c;
}

function $put_short(this$static, w){
  $put_byte(this$static, narrow_byte(w));
  $put_byte(this$static, narrow_byte(w >>> 8));
}

function $scan_tree(this$static, tree, max_code){
  var count, curlen, max_count, min_count, n, nextlen, prevlen;
  prevlen = (-1);
  nextlen = tree[1];
  count = 0;
  max_count = 7;
  min_count = 4;
  if (nextlen == 0) {
    max_count = 138;
    min_count = 3;
  }
  tree[(max_code + 1) * 2 + 1] = (-1);
  for (n = 0; n <= max_code; n++) {
    curlen = nextlen;
    nextlen = tree[(n + 1) * 2 + 1];
    if (++count < max_count && curlen == nextlen) {
      continue;
    }
     else if (count < min_count) {
      this$static.bl_tree[curlen * 2] += count;
    }
     else if (curlen != 0) {
      if (curlen != prevlen)
        this$static.bl_tree[curlen * 2]++;
      this$static.bl_tree[32]++;
    }
     else if (count <= 10) {
      this$static.bl_tree[34]++;
    }
     else {
      this$static.bl_tree[36]++;
    }
    count = 0;
    prevlen = curlen;
    if (nextlen == 0) {
      max_count = 138;
      min_count = 3;
    }
     else if (curlen == nextlen) {
      max_count = 6;
      min_count = 3;
    }
     else {
      max_count = 7;
      min_count = 4;
    }
  }
}

function $send_all_trees(this$static, lcodes, dcodes, blcodes){
  var rank;
  $send_bits(this$static, lcodes - 257, 5);
  $send_bits(this$static, dcodes - 1, 5);
  $send_bits(this$static, blcodes - 4, 4);
  for (rank = 0; rank < blcodes; rank++) {
    $send_bits(this$static, this$static.bl_tree[($clinit_55() , bl_order)[rank] * 2 + 1], 3);
  }
  $send_tree(this$static, this$static.dyn_ltree, lcodes - 1);
  $send_tree(this$static, this$static.dyn_dtree, dcodes - 1);
}

function $send_bits(this$static, value, length){
  var len, val;
  len = length;
  if (this$static.bi_valid > 16 - len) {
    val = value;
    this$static.bi_buf |= val << this$static.bi_valid & 65535;
    $put_short(this$static, this$static.bi_buf);
    this$static.bi_buf = narrow_short(val >>> 16 - this$static.bi_valid);
    this$static.bi_valid += len - 16;
  }
   else {
    this$static.bi_buf |= value << this$static.bi_valid & 65535;
    this$static.bi_valid += len;
  }
}

function $send_code(this$static, c, tree){
  var c2;
  c2 = c * 2;
  $send_bits(this$static, tree[c2] & 65535, tree[c2 + 1] & 65535);
}

function $send_tree(this$static, tree, max_code){
  var count, curlen, max_count, min_count, n, nextlen, prevlen;
  prevlen = (-1);
  nextlen = tree[1];
  count = 0;
  max_count = 7;
  min_count = 4;
  if (nextlen == 0) {
    max_count = 138;
    min_count = 3;
  }
  for (n = 0; n <= max_code; n++) {
    curlen = nextlen;
    nextlen = tree[(n + 1) * 2 + 1];
    if (++count < max_count && curlen == nextlen) {
      continue;
    }
     else if (count < min_count) {
      do {
        $send_code(this$static, curlen, this$static.bl_tree);
      }
       while (--count != 0);
    }
     else if (curlen != 0) {
      if (curlen != prevlen) {
        $send_code(this$static, curlen, this$static.bl_tree);
        count--;
      }
      $send_code(this$static, 16, this$static.bl_tree);
      $send_bits(this$static, count - 3, 2);
    }
     else if (count <= 10) {
      $send_code(this$static, 17, this$static.bl_tree);
      $send_bits(this$static, count - 3, 3);
    }
     else {
      $send_code(this$static, 18, this$static.bl_tree);
      $send_bits(this$static, count - 11, 7);
    }
    count = 0;
    prevlen = curlen;
    if (nextlen == 0) {
      max_count = 138;
      min_count = 3;
    }
     else if (curlen == nextlen) {
      max_count = 6;
      min_count = 3;
    }
     else {
      max_count = 7;
      min_count = 4;
    }
  }
}

function $set_data_type(this$static){
  var ascii_freq, bin_freq, n;
  n = 0;
  ascii_freq = 0;
  bin_freq = 0;
  while (n < 7) {
    bin_freq += this$static.dyn_ltree[n * 2];
    n++;
  }
  while (n < 128) {
    ascii_freq += this$static.dyn_ltree[n * 2];
    n++;
  }
  while (n < 256) {
    bin_freq += this$static.dyn_ltree[n * 2];
    n++;
  }
  this$static.data_type = narrow_byte(bin_freq > ascii_freq >>> 2?0:1);
}

function $tr_init(this$static){
  this$static.l_desc.dyn_tree = this$static.dyn_ltree;
  this$static.l_desc.stat_desc = ($clinit_54() , static_l_desc);
  this$static.d_desc.dyn_tree = this$static.dyn_dtree;
  this$static.d_desc.stat_desc = ($clinit_54() , static_d_desc);
  this$static.bl_desc.dyn_tree = this$static.bl_tree;
  this$static.bl_desc.stat_desc = ($clinit_54() , static_bl_desc);
  this$static.bi_buf = 0;
  this$static.bi_valid = 0;
  this$static.last_eob_len = 8;
  $init_block(this$static);
}

function smaller(tree, n, m, depth){
  $clinit_49();
  var tm2, tn2;
  tn2 = tree[n * 2];
  tm2 = tree[m * 2];
  return tn2 < tm2 || tn2 == tm2 && depth[n] <= depth[m];
}

function Deflate(){
}

_ = Deflate.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'Deflate';
_.typeId$ = 0;
_.bi_buf = 0;
_.bi_valid = 0;
_.bl_tree = null;
_.block_start = 0;
_.d_buf = 0;
_.data_type = 0;
_.dyn_dtree = null;
_.dyn_ltree = null;
_.good_match = 0;
_.hash_bits = 0;
_.hash_mask = 0;
_.hash_shift = 0;
_.hash_size = 0;
_.head = null;
_.heap_len = 0;
_.heap_max = 0;
_.ins_h = 0;
_.l_buf = 0;
_.last_eob_len = 0;
_.last_flush = 0;
_.last_lit = 0;
_.level = 0;
_.lit_bufsize = 0;
_.lookahead = 0;
_.match_available = 0;
_.match_length = 0;
_.match_start = 0;
_.matches = 0;
_.max_chain_length = 0;
_.max_lazy_match = 0;
_.nice_match = 0;
_.noheader = 0;
_.opt_len = 0;
_.pending = 0;
_.pending_buf = null;
_.pending_buf_size = 0;
_.pending_out = 0;
_.prev = null;
_.prev_length = 0;
_.prev_match = 0;
_.static_len = 0;
_.status = 0;
_.strategy = 0;
_.strm = null;
_.strstart = 0;
_.w_bits = 0;
_.w_mask = 0;
_.w_size = 0;
_.window_0 = null;
_.window_size = 0;
var config_table = null, z_errmsg;
function $Deflate$Config(this$static, good_length, max_lazy, nice_length, max_chain, func){
  this$static.good_length = good_length;
  this$static.max_lazy = max_lazy;
  this$static.nice_length = nice_length;
  this$static.max_chain = max_chain;
  this$static.func = func;
  return this$static;
}

function Deflate$Config(){
}

_ = Deflate$Config.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'Deflate$Config';
_.typeId$ = 0;
_.func = 0;
_.good_length = 0;
_.max_chain = 0;
_.max_lazy = 0;
_.nice_length = 0;
function $clinit_50(){
  $clinit_50 = nullMethod;
  inflate_mask = initValues('[I', 19, (-1), [0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535]);
  border = initValues('[I', 19, (-1), [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
}

function $$init_5(this$static){
  this$static.bb = initDims_0('[I', [19], [(-1)], [1], 0);
  this$static.tb = initDims_0('[I', [19], [(-1)], [1], 0);
  this$static.codes = $InfCodes(new InfCodes());
  this$static.inftree = $InfTree(new InfTree());
}

function $InfBlocks(this$static, z, checkfn, w){
  $clinit_50();
  $$init_5(this$static);
  this$static.hufts = initDims_0('[I', [19], [(-1)], [4320], 0);
  this$static.window_0 = initDims_0('[B', [0], [(-1)], [w], 0);
  this$static.end = w;
  this$static.checkfn = checkfn;
  this$static.mode = 0;
  $reset_3(this$static, z, null);
  return this$static;
}

function $free(this$static, z){
  $reset_3(this$static, z, null);
  this$static.window_0 = null;
  this$static.hufts = null;
}

function $inflate_flush(this$static, z, r){
  var n, p, q;
  p = z.next_out_index;
  q = this$static.read;
  n = (q <= this$static.write?this$static.write:this$static.end) - q;
  if (n > z.avail_out)
    n = z.avail_out;
  if (n != 0 && r == (-5))
    r = 0;
  z.avail_out -= n;
  z.total_out += n;
  if (this$static.checkfn !== null)
    z.adler = this$static.check = $adler32(z._adler, this$static.check, this$static.window_0, q, n);
  arraycopy(this$static.window_0, q, z.next_out, p, n);
  p += n;
  q += n;
  if (q == this$static.end) {
    q = 0;
    if (this$static.write == this$static.end)
      this$static.write = 0;
    n = this$static.write - q;
    if (n > z.avail_out)
      n = z.avail_out;
    if (n != 0 && r == (-5))
      r = 0;
    z.avail_out -= n;
    z.total_out += n;
    if (this$static.checkfn !== null)
      z.adler = this$static.check = $adler32(z._adler, this$static.check, this$static.window_0, q, n);
    arraycopy(this$static.window_0, q, z.next_out, p, n);
    p += n;
    q += n;
  }
  z.next_out_index = p;
  this$static.read = q;
  return r;
}

function $proc(this$static, z, r){
  var b, bd, bl, c, h, i, j, k, m, n, p, q, t, td, tl;
  {
    p = z.next_in_index;
    n = z.avail_in;
    b = this$static.bitb;
    k = this$static.bitk;
  }
  {
    q = this$static.write;
    m = q < this$static.read?this$static.read - q - 1:this$static.end - q;
  }
  while (true) {
    switch (this$static.mode) {
      case 0:
        while (k < 3) {
          if (n != 0) {
            r = 0;
          }
           else {
            this$static.bitb = b;
            this$static.bitk = k;
            z.avail_in = n;
            z.total_in += p - z.next_in_index;
            z.next_in_index = p;
            this$static.write = q;
            return $inflate_flush(this$static, z, r);
          }
          n--;
          b |= (z.next_in[p++] & 255) << k;
          k += 8;
        }

        t = b & 7;
        this$static.last = t & 1;
        switch (t >>> 1) {
          case 0:
            {
              b >>>= 3;
              k -= 3;
            }

            t = k & 7;
            {
              b >>>= t;
              k -= t;
            }

            this$static.mode = 1;
            break;
          case 1:
            {
              bl = initDims_0('[I', [19], [(-1)], [1], 0);
              bd = initDims_0('[I', [19], [(-1)], [1], 0);
              tl = initDims_0('[[I', [0], [7], [1], null);
              td = initDims_0('[[I', [0], [7], [1], null);
              inflate_trees_fixed(bl, bd, tl, td, z);
              $init(this$static.codes, bl[0], bd[0], tl[0], 0, td[0], 0, z);
            }

            {
              b >>>= 3;
              k -= 3;
            }

            this$static.mode = 6;
            break;
          case 2:
            {
              b >>>= 3;
              k -= 3;
            }

            this$static.mode = 3;
            break;
          case 3:
            {
              b >>>= 3;
              k -= 3;
            }

            this$static.mode = 9;
            z.msg = 'invalid block type';
            r = (-3);
            this$static.bitb = b;
            this$static.bitk = k;
            z.avail_in = n;
            z.total_in += p - z.next_in_index;
            z.next_in_index = p;
            this$static.write = q;
            return $inflate_flush(this$static, z, r);
        }

        break;
      case 1:
        while (k < 32) {
          if (n != 0) {
            r = 0;
          }
           else {
            this$static.bitb = b;
            this$static.bitk = k;
            z.avail_in = n;
            z.total_in += p - z.next_in_index;
            z.next_in_index = p;
            this$static.write = q;
            return $inflate_flush(this$static, z, r);
          }
          n--;
          b |= (z.next_in[p++] & 255) << k;
          k += 8;
        }

        if ((~b >>> 16 & 65535) != (b & 65535)) {
          this$static.mode = 9;
          z.msg = 'invalid stored block lengths';
          r = (-3);
          this$static.bitb = b;
          this$static.bitk = k;
          z.avail_in = n;
          z.total_in += p - z.next_in_index;
          z.next_in_index = p;
          this$static.write = q;
          return $inflate_flush(this$static, z, r);
        }

        this$static.left = b & 65535;
        b = k = 0;
        this$static.mode = this$static.left != 0?2:this$static.last != 0?7:0;
        break;
      case 2:
        if (n == 0) {
          this$static.bitb = b;
          this$static.bitk = k;
          z.avail_in = n;
          z.total_in += p - z.next_in_index;
          z.next_in_index = p;
          this$static.write = q;
          return $inflate_flush(this$static, z, r);
        }

        if (m == 0) {
          if (q == this$static.end && this$static.read != 0) {
            q = 0;
            m = q < this$static.read?this$static.read - q - 1:this$static.end - q;
          }
          if (m == 0) {
            this$static.write = q;
            r = $inflate_flush(this$static, z, r);
            q = this$static.write;
            m = q < this$static.read?this$static.read - q - 1:this$static.end - q;
            if (q == this$static.end && this$static.read != 0) {
              q = 0;
              m = q < this$static.read?this$static.read - q - 1:this$static.end - q;
            }
            if (m == 0) {
              this$static.bitb = b;
              this$static.bitk = k;
              z.avail_in = n;
              z.total_in += p - z.next_in_index;
              z.next_in_index = p;
              this$static.write = q;
              return $inflate_flush(this$static, z, r);
            }
          }
        }

        r = 0;
        t = this$static.left;
        if (t > n)
          t = n;
        if (t > m)
          t = m;
        arraycopy(z.next_in, p, this$static.window_0, q, t);
        p += t;
        n -= t;
        q += t;
        m -= t;
        if ((this$static.left -= t) != 0)
          break;
        this$static.mode = this$static.last != 0?7:0;
        break;
      case 3:
        while (k < 14) {
          if (n != 0) {
            r = 0;
          }
           else {
            this$static.bitb = b;
            this$static.bitk = k;
            z.avail_in = n;
            z.total_in += p - z.next_in_index;
            z.next_in_index = p;
            this$static.write = q;
            return $inflate_flush(this$static, z, r);
          }
          n--;
          b |= (z.next_in[p++] & 255) << k;
          k += 8;
        }

        this$static.table = t = b & 16383;
        if ((t & 31) > 29 || (t >> 5 & 31) > 29) {
          this$static.mode = 9;
          z.msg = 'too many length or distance symbols';
          r = (-3);
          this$static.bitb = b;
          this$static.bitk = k;
          z.avail_in = n;
          z.total_in += p - z.next_in_index;
          z.next_in_index = p;
          this$static.write = q;
          return $inflate_flush(this$static, z, r);
        }

        t = 258 + (t & 31) + (t >> 5 & 31);
        if (this$static.blens === null || this$static.blens.length_0 < t) {
          this$static.blens = initDims_0('[I', [19], [(-1)], [t], 0);
        }
         else {
          for (i = 0; i < t; i++) {
            this$static.blens[i] = 0;
          }
        }

        {
          b >>>= 14;
          k -= 14;
        }

        this$static.index = 0;
        this$static.mode = 4;
      case 4:
        while (this$static.index < 4 + (this$static.table >>> 10)) {
          while (k < 3) {
            if (n != 0) {
              r = 0;
            }
             else {
              this$static.bitb = b;
              this$static.bitk = k;
              z.avail_in = n;
              z.total_in += p - z.next_in_index;
              z.next_in_index = p;
              this$static.write = q;
              return $inflate_flush(this$static, z, r);
            }
            n--;
            b |= (z.next_in[p++] & 255) << k;
            k += 8;
          }
          this$static.blens[border[this$static.index++]] = b & 7;
          {
            b >>>= 3;
            k -= 3;
          }
        }

        while (this$static.index < 19) {
          this$static.blens[border[this$static.index++]] = 0;
        }

        this$static.bb[0] = 7;
        t = $inflate_trees_bits(this$static.inftree, this$static.blens, this$static.bb, this$static.tb, this$static.hufts, z);
        if (t != 0) {
          r = t;
          if (r == (-3)) {
            this$static.blens = null;
            this$static.mode = 9;
          }
          this$static.bitb = b;
          this$static.bitk = k;
          z.avail_in = n;
          z.total_in += p - z.next_in_index;
          z.next_in_index = p;
          this$static.write = q;
          return $inflate_flush(this$static, z, r);
        }

        this$static.index = 0;
        this$static.mode = 5;
      case 5:
        while (true) {
          t = this$static.table;
          if (this$static.index >= 258 + (t & 31) + (t >> 5 & 31)) {
            break;
          }
          t = this$static.bb[0];
          while (k < t) {
            if (n != 0) {
              r = 0;
            }
             else {
              this$static.bitb = b;
              this$static.bitk = k;
              z.avail_in = n;
              z.total_in += p - z.next_in_index;
              z.next_in_index = p;
              this$static.write = q;
              return $inflate_flush(this$static, z, r);
            }
            n--;
            b |= (z.next_in[p++] & 255) << k;
            k += 8;
          }
          t = this$static.hufts[(this$static.tb[0] + (b & inflate_mask[t])) * 3 + 1];
          c = this$static.hufts[(this$static.tb[0] + (b & inflate_mask[t])) * 3 + 2];
          if (c < 16) {
            b >>>= t;
            k -= t;
            this$static.blens[this$static.index++] = c;
          }
           else {
            i = c == 18?7:c - 14;
            j = c == 18?11:3;
            while (k < t + i) {
              if (n != 0) {
                r = 0;
              }
               else {
                this$static.bitb = b;
                this$static.bitk = k;
                z.avail_in = n;
                z.total_in += p - z.next_in_index;
                z.next_in_index = p;
                this$static.write = q;
                return $inflate_flush(this$static, z, r);
              }
              n--;
              b |= (z.next_in[p++] & 255) << k;
              k += 8;
            }
            b >>>= t;
            k -= t;
            j += b & inflate_mask[i];
            b >>>= i;
            k -= i;
            i = this$static.index;
            t = this$static.table;
            if (i + j > 258 + (t & 31) + (t >> 5 & 31) || c == 16 && i < 1) {
              this$static.blens = null;
              this$static.mode = 9;
              z.msg = 'invalid bit length repeat';
              r = (-3);
              this$static.bitb = b;
              this$static.bitk = k;
              z.avail_in = n;
              z.total_in += p - z.next_in_index;
              z.next_in_index = p;
              this$static.write = q;
              return $inflate_flush(this$static, z, r);
            }
            c = c == 16?this$static.blens[i - 1]:0;
            do {
              this$static.blens[i++] = c;
            }
             while (--j != 0);
            this$static.index = i;
          }
        }

        this$static.tb[0] = (-1);
        {
          bl = initDims_0('[I', [19], [(-1)], [1], 0);
          bd = initDims_0('[I', [19], [(-1)], [1], 0);
          tl = initDims_0('[I', [19], [(-1)], [1], 0);
          td = initDims_0('[I', [19], [(-1)], [1], 0);
          bl[0] = 9;
          bd[0] = 6;
          t = this$static.table;
          t = $inflate_trees_dynamic(this$static.inftree, 257 + (t & 31), 1 + (t >> 5 & 31), this$static.blens, bl, bd, tl, td, this$static.hufts, z);
          if (t != 0) {
            if (t == (-3)) {
              this$static.blens = null;
              this$static.mode = 9;
            }
            r = t;
            this$static.bitb = b;
            this$static.bitk = k;
            z.avail_in = n;
            z.total_in += p - z.next_in_index;
            z.next_in_index = p;
            this$static.write = q;
            return $inflate_flush(this$static, z, r);
          }
          $init(this$static.codes, bl[0], bd[0], this$static.hufts, tl[0], this$static.hufts, td[0], z);
        }

        this$static.mode = 6;
      case 6:
        this$static.bitb = b;
        this$static.bitk = k;
        z.avail_in = n;
        z.total_in += p - z.next_in_index;
        z.next_in_index = p;
        this$static.write = q;
        if ((r = $proc_0(this$static.codes, this$static, z, r)) != 1) {
          return $inflate_flush(this$static, z, r);
        }

        r = 0;
        p = z.next_in_index;
        n = z.avail_in;
        b = this$static.bitb;
        k = this$static.bitk;
        q = this$static.write;
        m = q < this$static.read?this$static.read - q - 1:this$static.end - q;
        if (this$static.last == 0) {
          this$static.mode = 0;
          break;
        }

        this$static.mode = 7;
      case 7:
        this$static.write = q;
        r = $inflate_flush(this$static, z, r);
        q = this$static.write;
        m = q < this$static.read?this$static.read - q - 1:this$static.end - q;
        if (this$static.read != this$static.write) {
          this$static.bitb = b;
          this$static.bitk = k;
          z.avail_in = n;
          z.total_in += p - z.next_in_index;
          z.next_in_index = p;
          this$static.write = q;
          return $inflate_flush(this$static, z, r);
        }

        this$static.mode = 8;
      case 8:
        r = 1;
        this$static.bitb = b;
        this$static.bitk = k;
        z.avail_in = n;
        z.total_in += p - z.next_in_index;
        z.next_in_index = p;
        this$static.write = q;
        return $inflate_flush(this$static, z, r);
      case 9:
        r = (-3);
        this$static.bitb = b;
        this$static.bitk = k;
        z.avail_in = n;
        z.total_in += p - z.next_in_index;
        z.next_in_index = p;
        this$static.write = q;
        return $inflate_flush(this$static, z, r);
      default:r = (-2);
        this$static.bitb = b;
        this$static.bitk = k;
        z.avail_in = n;
        z.total_in += p - z.next_in_index;
        z.next_in_index = p;
        this$static.write = q;
        return $inflate_flush(this$static, z, r);
    }
  }
}

function $reset_3(this$static, z, c){
  if (c !== null)
    c[0] = this$static.check;
  this$static.mode = 0;
  this$static.bitk = 0;
  this$static.bitb = 0;
  this$static.read = this$static.write = 0;
  if (this$static.checkfn !== null)
    z.adler = this$static.check = $adler32(z._adler, 0, null, 0, 0);
}

function InfBlocks(){
}

_ = InfBlocks.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'InfBlocks';
_.typeId$ = 0;
_.bitb = 0;
_.bitk = 0;
_.blens = null;
_.check = 0;
_.checkfn = null;
_.end = 0;
_.hufts = null;
_.index = 0;
_.last = 0;
_.left = 0;
_.mode = 0;
_.read = 0;
_.table = 0;
_.window_0 = null;
_.write = 0;
var border, inflate_mask;
function $clinit_51(){
  $clinit_51 = nullMethod;
  inflate_mask_0 = initValues('[I', 19, (-1), [0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535]);
}

function $InfCodes(this$static){
  $clinit_51();
  return this$static;
}

function $inflate_fast(this$static, bl, bd, tl, tl_index, td, td_index, s, z){
  var b, c, d, e, k, m, md, ml, n, p, q, r, t, tp, tp_index, tp_index_t_3;
  p = z.next_in_index;
  n = z.avail_in;
  b = s.bitb;
  k = s.bitk;
  q = s.write;
  m = q < s.read?s.read - q - 1:s.end - q;
  ml = inflate_mask_0[bl];
  md = inflate_mask_0[bd];
  do {
    while (k < 20) {
      n--;
      b |= (z.next_in[p++] & 255) << k;
      k += 8;
    }
    t = b & ml;
    tp = tl;
    tp_index = tl_index;
    tp_index_t_3 = (tp_index + t) * 3;
    if ((e = tp[tp_index_t_3]) == 0) {
      b >>= tp[tp_index_t_3 + 1];
      k -= tp[tp_index_t_3 + 1];
      s.window_0[q++] = narrow_byte(tp[tp_index_t_3 + 2]);
      m--;
      continue;
    }
    do {
      b >>= tp[tp_index_t_3 + 1];
      k -= tp[tp_index_t_3 + 1];
      if ((e & 16) != 0) {
        e &= 15;
        c = tp[tp_index_t_3 + 2] + (b & inflate_mask_0[e]);
        b >>= e;
        k -= e;
        while (k < 15) {
          n--;
          b |= (z.next_in[p++] & 255) << k;
          k += 8;
        }
        t = b & md;
        tp = td;
        tp_index = td_index;
        tp_index_t_3 = (tp_index + t) * 3;
        e = tp[tp_index_t_3];
        do {
          b >>= tp[tp_index_t_3 + 1];
          k -= tp[tp_index_t_3 + 1];
          if ((e & 16) != 0) {
            e &= 15;
            while (k < e) {
              n--;
              b |= (z.next_in[p++] & 255) << k;
              k += 8;
            }
            d = tp[tp_index_t_3 + 2] + (b & inflate_mask_0[e]);
            b >>= e;
            k -= e;
            m -= c;
            if (q >= d) {
              r = q - d;
              if (q - r > 0 && 2 > q - r) {
                s.window_0[q++] = s.window_0[r++];
                s.window_0[q++] = s.window_0[r++];
                c -= 2;
              }
               else {
                arraycopy(s.window_0, r, s.window_0, q, 2);
                q += 2;
                r += 2;
                c -= 2;
              }
            }
             else {
              r = q - d;
              do {
                r += s.end;
              }
               while (r < 0);
              e = s.end - r;
              if (c > e) {
                c -= e;
                if (q - r > 0 && e > q - r) {
                  do {
                    s.window_0[q++] = s.window_0[r++];
                  }
                   while (--e != 0);
                }
                 else {
                  arraycopy(s.window_0, r, s.window_0, q, e);
                  q += e;
                  r += e;
                  e = 0;
                }
                r = 0;
              }
            }
            if (q - r > 0 && c > q - r) {
              do {
                s.window_0[q++] = s.window_0[r++];
              }
               while (--c != 0);
            }
             else {
              arraycopy(s.window_0, r, s.window_0, q, c);
              q += c;
              r += c;
              c = 0;
            }
            break;
          }
           else if ((e & 64) == 0) {
            t += tp[tp_index_t_3 + 2];
            t += b & inflate_mask_0[e];
            tp_index_t_3 = (tp_index + t) * 3;
            e = tp[tp_index_t_3];
          }
           else {
            z.msg = 'invalid distance code';
            c = z.avail_in - n;
            c = k >> 3 < c?k >> 3:c;
            n += c;
            p -= c;
            k -= c << 3;
            s.bitb = b;
            s.bitk = k;
            z.avail_in = n;
            z.total_in += p - z.next_in_index;
            z.next_in_index = p;
            s.write = q;
            return (-3);
          }
        }
         while (true);
        break;
      }
      if ((e & 64) == 0) {
        t += tp[tp_index_t_3 + 2];
        t += b & inflate_mask_0[e];
        tp_index_t_3 = (tp_index + t) * 3;
        if ((e = tp[tp_index_t_3]) == 0) {
          b >>= tp[tp_index_t_3 + 1];
          k -= tp[tp_index_t_3 + 1];
          s.window_0[q++] = narrow_byte(tp[tp_index_t_3 + 2]);
          m--;
          break;
        }
      }
       else if ((e & 32) != 0) {
        c = z.avail_in - n;
        c = k >> 3 < c?k >> 3:c;
        n += c;
        p -= c;
        k -= c << 3;
        s.bitb = b;
        s.bitk = k;
        z.avail_in = n;
        z.total_in += p - z.next_in_index;
        z.next_in_index = p;
        s.write = q;
        return 1;
      }
       else {
        z.msg = 'invalid literal/length code';
        c = z.avail_in - n;
        c = k >> 3 < c?k >> 3:c;
        n += c;
        p -= c;
        k -= c << 3;
        s.bitb = b;
        s.bitk = k;
        z.avail_in = n;
        z.total_in += p - z.next_in_index;
        z.next_in_index = p;
        s.write = q;
        return (-3);
      }
    }
     while (true);
  }
   while (m >= 258 && n >= 10);
  c = z.avail_in - n;
  c = k >> 3 < c?k >> 3:c;
  n += c;
  p -= c;
  k -= c << 3;
  s.bitb = b;
  s.bitk = k;
  z.avail_in = n;
  z.total_in += p - z.next_in_index;
  z.next_in_index = p;
  s.write = q;
  return 0;
}

function $init(this$static, bl, bd, tl, tl_index, td, td_index, z){
  this$static.mode = 0;
  this$static.lbits = narrow_byte(bl);
  this$static.dbits = narrow_byte(bd);
  this$static.ltree = tl;
  this$static.ltree_index = tl_index;
  this$static.dtree = td;
  this$static.dtree_index = td_index;
  this$static.tree = null;
}

function $proc_0(this$static, s, z, r){
  var b, e, f, j, k, m, n, p, q, t, tindex;
  b = 0;
  k = 0;
  p = 0;
  p = z.next_in_index;
  n = z.avail_in;
  b = s.bitb;
  k = s.bitk;
  q = s.write;
  m = q < s.read?s.read - q - 1:s.end - q;
  while (true) {
    switch (this$static.mode) {
      case 0:
        if (m >= 258 && n >= 10) {
          s.bitb = b;
          s.bitk = k;
          z.avail_in = n;
          z.total_in += p - z.next_in_index;
          z.next_in_index = p;
          s.write = q;
          r = $inflate_fast(this$static, this$static.lbits, this$static.dbits, this$static.ltree, this$static.ltree_index, this$static.dtree, this$static.dtree_index, s, z);
          p = z.next_in_index;
          n = z.avail_in;
          b = s.bitb;
          k = s.bitk;
          q = s.write;
          m = q < s.read?s.read - q - 1:s.end - q;
          if (r != 0) {
            this$static.mode = r == 1?7:9;
            break;
          }
        }

        this$static.need = this$static.lbits;
        this$static.tree = this$static.ltree;
        this$static.tree_index = this$static.ltree_index;
        this$static.mode = 1;
      case 1:
        j = this$static.need;
        while (k < j) {
          if (n != 0)
            r = 0;
          else {
            s.bitb = b;
            s.bitk = k;
            z.avail_in = n;
            z.total_in += p - z.next_in_index;
            z.next_in_index = p;
            s.write = q;
            return $inflate_flush(s, z, r);
          }
          n--;
          b |= (z.next_in[p++] & 255) << k;
          k += 8;
        }

        tindex = (this$static.tree_index + (b & inflate_mask_0[j])) * 3;
        b >>>= this$static.tree[tindex + 1];
        k -= this$static.tree[tindex + 1];
        e = this$static.tree[tindex];
        if (e == 0) {
          this$static.lit = this$static.tree[tindex + 2];
          this$static.mode = 6;
          break;
        }

        if ((e & 16) != 0) {
          this$static.get = e & 15;
          this$static.len = this$static.tree[tindex + 2];
          this$static.mode = 2;
          break;
        }

        if ((e & 64) == 0) {
          this$static.need = e;
          this$static.tree_index = round_int(tindex / 3) + this$static.tree[tindex + 2];
          break;
        }

        if ((e & 32) != 0) {
          this$static.mode = 7;
          break;
        }

        this$static.mode = 9;
        z.msg = 'invalid literal/length code';
        r = (-3);
        s.bitb = b;
        s.bitk = k;
        z.avail_in = n;
        z.total_in += p - z.next_in_index;
        z.next_in_index = p;
        s.write = q;
        return $inflate_flush(s, z, r);
      case 2:
        j = this$static.get;
        while (k < j) {
          if (n != 0)
            r = 0;
          else {
            s.bitb = b;
            s.bitk = k;
            z.avail_in = n;
            z.total_in += p - z.next_in_index;
            z.next_in_index = p;
            s.write = q;
            return $inflate_flush(s, z, r);
          }
          n--;
          b |= (z.next_in[p++] & 255) << k;
          k += 8;
        }

        this$static.len += b & inflate_mask_0[j];
        b >>= j;
        k -= j;
        this$static.need = this$static.dbits;
        this$static.tree = this$static.dtree;
        this$static.tree_index = this$static.dtree_index;
        this$static.mode = 3;
      case 3:
        j = this$static.need;
        while (k < j) {
          if (n != 0)
            r = 0;
          else {
            s.bitb = b;
            s.bitk = k;
            z.avail_in = n;
            z.total_in += p - z.next_in_index;
            z.next_in_index = p;
            s.write = q;
            return $inflate_flush(s, z, r);
          }
          n--;
          b |= (z.next_in[p++] & 255) << k;
          k += 8;
        }

        tindex = (this$static.tree_index + (b & inflate_mask_0[j])) * 3;
        b >>= this$static.tree[tindex + 1];
        k -= this$static.tree[tindex + 1];
        e = this$static.tree[tindex];
        if ((e & 16) != 0) {
          this$static.get = e & 15;
          this$static.dist = this$static.tree[tindex + 2];
          this$static.mode = 4;
          break;
        }

        if ((e & 64) == 0) {
          this$static.need = e;
          this$static.tree_index = round_int(tindex / 3) + this$static.tree[tindex + 2];
          break;
        }

        this$static.mode = 9;
        z.msg = 'invalid distance code';
        r = (-3);
        s.bitb = b;
        s.bitk = k;
        z.avail_in = n;
        z.total_in += p - z.next_in_index;
        z.next_in_index = p;
        s.write = q;
        return $inflate_flush(s, z, r);
      case 4:
        j = this$static.get;
        while (k < j) {
          if (n != 0)
            r = 0;
          else {
            s.bitb = b;
            s.bitk = k;
            z.avail_in = n;
            z.total_in += p - z.next_in_index;
            z.next_in_index = p;
            s.write = q;
            return $inflate_flush(s, z, r);
          }
          n--;
          b |= (z.next_in[p++] & 255) << k;
          k += 8;
        }

        this$static.dist += b & inflate_mask_0[j];
        b >>= j;
        k -= j;
        this$static.mode = 5;
      case 5:
        f = q - this$static.dist;
        while (f < 0) {
          f += s.end;
        }

        while (this$static.len != 0) {
          if (m == 0) {
            if (q == s.end && s.read != 0) {
              q = 0;
              m = q < s.read?s.read - q - 1:s.end - q;
            }
            if (m == 0) {
              s.write = q;
              r = $inflate_flush(s, z, r);
              q = s.write;
              m = q < s.read?s.read - q - 1:s.end - q;
              if (q == s.end && s.read != 0) {
                q = 0;
                m = q < s.read?s.read - q - 1:s.end - q;
              }
              if (m == 0) {
                s.bitb = b;
                s.bitk = k;
                z.avail_in = n;
                z.total_in += p - z.next_in_index;
                z.next_in_index = p;
                s.write = q;
                return $inflate_flush(s, z, r);
              }
            }
          }
          s.window_0[q++] = s.window_0[f++];
          m--;
          if (f == s.end)
            f = 0;
          this$static.len--;
        }

        this$static.mode = 0;
        break;
      case 6:
        if (m == 0) {
          if (q == s.end && s.read != 0) {
            q = 0;
            m = q < s.read?s.read - q - 1:s.end - q;
          }
          if (m == 0) {
            s.write = q;
            r = $inflate_flush(s, z, r);
            q = s.write;
            m = q < s.read?s.read - q - 1:s.end - q;
            if (q == s.end && s.read != 0) {
              q = 0;
              m = q < s.read?s.read - q - 1:s.end - q;
            }
            if (m == 0) {
              s.bitb = b;
              s.bitk = k;
              z.avail_in = n;
              z.total_in += p - z.next_in_index;
              z.next_in_index = p;
              s.write = q;
              return $inflate_flush(s, z, r);
            }
          }
        }

        r = 0;
        s.window_0[q++] = narrow_byte(this$static.lit);
        m--;
        this$static.mode = 0;
        break;
      case 7:
        if (k > 7) {
          k -= 8;
          n++;
          p--;
        }

        s.write = q;
        r = $inflate_flush(s, z, r);
        q = s.write;
        m = q < s.read?s.read - q - 1:s.end - q;
        if (s.read != s.write) {
          s.bitb = b;
          s.bitk = k;
          z.avail_in = n;
          z.total_in += p - z.next_in_index;
          z.next_in_index = p;
          s.write = q;
          return $inflate_flush(s, z, r);
        }

        this$static.mode = 8;
      case 8:
        r = 1;
        s.bitb = b;
        s.bitk = k;
        z.avail_in = n;
        z.total_in += p - z.next_in_index;
        z.next_in_index = p;
        s.write = q;
        return $inflate_flush(s, z, r);
      case 9:
        r = (-3);
        s.bitb = b;
        s.bitk = k;
        z.avail_in = n;
        z.total_in += p - z.next_in_index;
        z.next_in_index = p;
        s.write = q;
        return $inflate_flush(s, z, r);
      default:r = (-2);
        s.bitb = b;
        s.bitk = k;
        z.avail_in = n;
        z.total_in += p - z.next_in_index;
        z.next_in_index = p;
        s.write = q;
        return $inflate_flush(s, z, r);
    }
  }
}

function InfCodes(){
}

_ = InfCodes.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'InfCodes';
_.typeId$ = 0;
_.dbits = 0;
_.dist = 0;
_.dtree = null;
_.dtree_index = 0;
_.get = 0;
_.lbits = 0;
_.len = 0;
_.lit = 0;
_.ltree = null;
_.ltree_index = 0;
_.mode = 0;
_.need = 0;
_.tree = null;
_.tree_index = 0;
var inflate_mask_0;
function $clinit_52(){
  $clinit_52 = nullMethod;
  fixed_tl = initValues('[I', 19, (-1), [96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, 192, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 160, 0, 8, 0, 0, 8, 128, 0, 8, 64, 0, 9, 224, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 144, 83, 7, 59, 0, 8, 120, 0, 8, 56, 0, 9, 208, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9, 176, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 240, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 200, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 168, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 232, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 152, 84, 7, 83, 0, 8, 124, 0, 8, 60, 0, 9, 216, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 184, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 248, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 196, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 164, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, 228, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 148, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 212, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 180, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 244, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 204, 81, 7, 15, 0, 8, 102, 0, 8, 38, 0, 9, 172, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 236, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 156, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 220, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 188, 0, 8, 14, 0, 8, 142, 0, 8, 78, 0, 9, 252, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, 194, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 162, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 226, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, 146, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 210, 81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 178, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 242, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, 0, 8, 53, 0, 9, 202, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 170, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 234, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 154, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 218, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 186, 0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 250, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 198, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 166, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 230, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 150, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 214, 82, 7, 19, 0, 8, 107, 0, 8, 43, 0, 9, 182, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 246, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, 206, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 174, 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 238, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 158, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 222, 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9, 190, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 254, 96, 7, 256, 0, 8, 80, 0, 8, 16, 84, 8, 115, 82, 7, 31, 0, 8, 112, 0, 8, 48, 0, 9, 193, 80, 7, 10, 0, 8, 96, 0, 8, 32, 0, 9, 161, 0, 8, 0, 0, 8, 128, 0, 8, 64, 0, 9, 225, 80, 7, 6, 0, 8, 88, 0, 8, 24, 0, 9, 145, 83, 7, 59, 0, 8, 120, 0, 8, 56, 0, 9, 209, 81, 7, 17, 0, 8, 104, 0, 8, 40, 0, 9, 177, 0, 8, 8, 0, 8, 136, 0, 8, 72, 0, 9, 241, 80, 7, 4, 0, 8, 84, 0, 8, 20, 85, 8, 227, 83, 7, 43, 0, 8, 116, 0, 8, 52, 0, 9, 201, 81, 7, 13, 0, 8, 100, 0, 8, 36, 0, 9, 169, 0, 8, 4, 0, 8, 132, 0, 8, 68, 0, 9, 233, 80, 7, 8, 0, 8, 92, 0, 8, 28, 0, 9, 153, 84, 7, 83, 0, 8, 124, 0, 8, 60, 0, 9, 217, 82, 7, 23, 0, 8, 108, 0, 8, 44, 0, 9, 185, 0, 8, 12, 0, 8, 140, 0, 8, 76, 0, 9, 249, 80, 7, 3, 0, 8, 82, 0, 8, 18, 85, 8, 163, 83, 7, 35, 0, 8, 114, 0, 8, 50, 0, 9, 197, 81, 7, 11, 0, 8, 98, 0, 8, 34, 0, 9, 165, 0, 8, 2, 0, 8, 130, 0, 8, 66, 0, 9, 229, 80, 7, 7, 0, 8, 90, 0, 8, 26, 0, 9, 149, 84, 7, 67, 0, 8, 122, 0, 8, 58, 0, 9, 213, 82, 7, 19, 0, 8, 106, 0, 8, 42, 0, 9, 181, 0, 8, 10, 0, 8, 138, 0, 8, 74, 0, 9, 245, 80, 7, 5, 0, 8, 86, 0, 8, 22, 192, 8, 0, 83, 7, 51, 0, 8, 118, 0, 8, 54, 0, 9, 205, 81, 7, 15, 0, 8, 102, 0, 8, 38, 0, 9, 173, 0, 8, 6, 0, 8, 134, 0, 8, 70, 0, 9, 237, 80, 7, 9, 0, 8, 94, 0, 8, 30, 0, 9, 157, 84, 7, 99, 0, 8, 126, 0, 8, 62, 0, 9, 221, 82, 7, 27, 0, 8, 110, 0, 8, 46, 0, 9, 189, 0, 8, 14, 0, 8, 142, 0, 8, 78, 0, 9, 253, 96, 7, 256, 0, 8, 81, 0, 8, 17, 85, 8, 131, 82, 7, 31, 0, 8, 113, 0, 8, 49, 0, 9, 195, 80, 7, 10, 0, 8, 97, 0, 8, 33, 0, 9, 163, 0, 8, 1, 0, 8, 129, 0, 8, 65, 0, 9, 227, 80, 7, 6, 0, 8, 89, 0, 8, 25, 0, 9, 147, 83, 7, 59, 0, 8, 121, 0, 8, 57, 0, 9, 211, 81, 7, 17, 0, 8, 105, 0, 8, 41, 0, 9, 179, 0, 8, 9, 0, 8, 137, 0, 8, 73, 0, 9, 243, 80, 7, 4, 0, 8, 85, 0, 8, 21, 80, 8, 258, 83, 7, 43, 0, 8, 117, 0, 8, 53, 0, 9, 203, 81, 7, 13, 0, 8, 101, 0, 8, 37, 0, 9, 171, 0, 8, 5, 0, 8, 133, 0, 8, 69, 0, 9, 235, 80, 7, 8, 0, 8, 93, 0, 8, 29, 0, 9, 155, 84, 7, 83, 0, 8, 125, 0, 8, 61, 0, 9, 219, 82, 7, 23, 0, 8, 109, 0, 8, 45, 0, 9, 187, 0, 8, 13, 0, 8, 141, 0, 8, 77, 0, 9, 251, 80, 7, 3, 0, 8, 83, 0, 8, 19, 85, 8, 195, 83, 7, 35, 0, 8, 115, 0, 8, 51, 0, 9, 199, 81, 7, 11, 0, 8, 99, 0, 8, 35, 0, 9, 167, 0, 8, 3, 0, 8, 131, 0, 8, 67, 0, 9, 231, 80, 7, 7, 0, 8, 91, 0, 8, 27, 0, 9, 151, 84, 7, 67, 0, 8, 123, 0, 8, 59, 0, 9, 215, 82, 7, 19, 0, 8, 107, 0, 8, 43, 0, 9, 183, 0, 8, 11, 0, 8, 139, 0, 8, 75, 0, 9, 247, 80, 7, 5, 0, 8, 87, 0, 8, 23, 192, 8, 0, 83, 7, 51, 0, 8, 119, 0, 8, 55, 0, 9, 207, 81, 7, 15, 0, 8, 103, 0, 8, 39, 0, 9, 175, 0, 8, 7, 0, 8, 135, 0, 8, 71, 0, 9, 239, 80, 7, 9, 0, 8, 95, 0, 8, 31, 0, 9, 159, 84, 7, 99, 0, 8, 127, 0, 8, 63, 0, 9, 223, 82, 7, 27, 0, 8, 111, 0, 8, 47, 0, 9, 191, 0, 8, 15, 0, 8, 143, 0, 8, 79, 0, 9, 255]);
  fixed_td = initValues('[I', 19, (-1), [80, 5, 1, 87, 5, 257, 83, 5, 17, 91, 5, 4097, 81, 5, 5, 89, 5, 1025, 85, 5, 65, 93, 5, 16385, 80, 5, 3, 88, 5, 513, 84, 5, 33, 92, 5, 8193, 82, 5, 9, 90, 5, 2049, 86, 5, 129, 192, 5, 24577, 80, 5, 2, 87, 5, 385, 83, 5, 25, 91, 5, 6145, 81, 5, 7, 89, 5, 1537, 85, 5, 97, 93, 5, 24577, 80, 5, 4, 88, 5, 769, 84, 5, 49, 92, 5, 12289, 82, 5, 13, 90, 5, 3073, 86, 5, 193, 192, 5, 24577]);
  cplens = initValues('[I', 19, (-1), [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0]);
  cplext = initValues('[I', 19, (-1), [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 112, 112]);
  cpdist = initValues('[I', 19, (-1), [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577]);
  cpdext = initValues('[I', 19, (-1), [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);
}

function $InfTree(this$static){
  $clinit_52();
  return this$static;
}

function $huft_build(this$static, b, bindex, n, s, d, e, t, m, hp, hn, v){
  var a, f, g, h, i, j, k, l, mask, p, q, w, xp, y, z;
  p = 0;
  i = n;
  do {
    this$static.c[b[bindex + p]]++;
    p++;
    i--;
  }
   while (i != 0);
  if (this$static.c[0] == n) {
    t[0] = (-1);
    m[0] = 0;
    return 0;
  }
  l = m[0];
  for (j = 1; j <= 15; j++)
    if (this$static.c[j] != 0)
      break;
  k = j;
  if (l < j) {
    l = j;
  }
  for (i = 15; i != 0; i--) {
    if (this$static.c[i] != 0)
      break;
  }
  g = i;
  if (l > i) {
    l = i;
  }
  m[0] = l;
  for (y = 1 << j; j < i; j++ , y <<= 1) {
    if ((y -= this$static.c[j]) < 0) {
      return (-3);
    }
  }
  if ((y -= this$static.c[i]) < 0) {
    return (-3);
  }
  this$static.c[i] += y;
  this$static.x[1] = j = 0;
  p = 1;
  xp = 2;
  while (--i != 0) {
    this$static.x[xp] = j += this$static.c[p];
    xp++;
    p++;
  }
  i = 0;
  p = 0;
  do {
    if ((j = b[bindex + p]) != 0) {
      v[this$static.x[j]++] = i;
    }
    p++;
  }
   while (++i < n);
  n = this$static.x[g];
  this$static.x[0] = i = 0;
  p = 0;
  h = (-1);
  w = -l;
  this$static.u[0] = 0;
  q = 0;
  z = 0;
  for (; k <= g; k++) {
    a = this$static.c[k];
    while (a-- != 0) {
      while (k > w + l) {
        h++;
        w += l;
        z = g - w;
        z = z > l?l:z;
        if ((f = 1 << (j = k - w)) > a + 1) {
          f -= a + 1;
          xp = k;
          if (j < z) {
            while (++j < z) {
              if ((f <<= 1) <= this$static.c[++xp])
                break;
              f -= this$static.c[xp];
            }
          }
        }
        z = 1 << j;
        if (hn[0] + z > 1440) {
          return (-3);
        }
        this$static.u[h] = q = hn[0];
        hn[0] += z;
        if (h != 0) {
          this$static.x[h] = i;
          this$static.r[0] = narrow_byte(j);
          this$static.r[1] = narrow_byte(l);
          j = i >>> w - l;
          this$static.r[2] = q - this$static.u[h - 1] - j;
          arraycopy_0(this$static.r, 0, hp, (this$static.u[h - 1] + j) * 3, 3);
        }
         else {
          t[0] = q;
        }
      }
      this$static.r[1] = narrow_byte(k - w);
      if (p >= n) {
        this$static.r[0] = 192;
      }
       else if (v[p] < s) {
        this$static.r[0] = narrow_byte(v[p] < 256?0:96);
        this$static.r[2] = v[p++];
      }
       else {
        this$static.r[0] = narrow_byte(e[v[p] - s] + 16 + 64);
        this$static.r[2] = d[v[p++] - s];
      }
      f = 1 << k - w;
      for (j = i >>> w; j < z; j += f) {
        arraycopy_0(this$static.r, 0, hp, (q + j) * 3, 3);
      }
      for (j = 1 << k - 1; (i & j) != 0; j >>>= 1) {
        i ^= j;
      }
      i ^= j;
      mask = (1 << w) - 1;
      while ((i & mask) != this$static.x[h]) {
        h--;
        w -= l;
        mask = (1 << w) - 1;
      }
    }
  }
  return y != 0 && g != 1?(-5):0;
}

function $inflate_trees_bits(this$static, c, bb, tb, hp, z){
  var result;
  $initWorkArea(this$static, 19);
  this$static.hn[0] = 0;
  result = $huft_build(this$static, c, 0, 19, 19, null, null, tb, bb, hp, this$static.hn, this$static.v);
  if (result == (-3)) {
    z.msg = 'oversubscribed dynamic bit lengths tree';
  }
   else if (result == (-5) || bb[0] == 0) {
    z.msg = 'incomplete dynamic bit lengths tree';
    result = (-3);
  }
  return result;
}

function $inflate_trees_dynamic(this$static, nl, nd, c, bl, bd, tl, td, hp, z){
  var result;
  $initWorkArea(this$static, 288);
  this$static.hn[0] = 0;
  result = $huft_build(this$static, c, 0, nl, 257, cplens, cplext, tl, bl, hp, this$static.hn, this$static.v);
  if (result != 0 || bl[0] == 0) {
    if (result == (-3)) {
      z.msg = 'oversubscribed literal/length tree';
    }
     else if (result != (-4)) {
      z.msg = 'incomplete literal/length tree';
      result = (-3);
    }
    return result;
  }
  $initWorkArea(this$static, 288);
  result = $huft_build(this$static, c, nl, nd, 0, cpdist, cpdext, td, bd, hp, this$static.hn, this$static.v);
  if (result != 0 || bd[0] == 0 && nl > 257) {
    if (result == (-3)) {
      z.msg = 'oversubscribed distance tree';
    }
     else if (result == (-5)) {
      z.msg = 'incomplete distance tree';
      result = (-3);
    }
     else if (result != (-4)) {
      z.msg = 'empty distance tree with lengths';
      result = (-3);
    }
    return result;
  }
  return 0;
}

function $initWorkArea(this$static, vsize){
  var i;
  if (this$static.hn === null) {
    this$static.hn = initDims_0('[I', [19], [(-1)], [1], 0);
    this$static.v = initDims_0('[I', [19], [(-1)], [vsize], 0);
    this$static.c = initDims_0('[I', [19], [(-1)], [16], 0);
    this$static.r = initDims_0('[I', [19], [(-1)], [3], 0);
    this$static.u = initDims_0('[I', [19], [(-1)], [15], 0);
    this$static.x = initDims_0('[I', [19], [(-1)], [16], 0);
  }
  if (this$static.v.length_0 < vsize) {
    this$static.v = initDims_0('[I', [19], [(-1)], [vsize], 0);
  }
  for (i = 0; i < vsize; i++) {
    this$static.v[i] = 0;
  }
  for (i = 0; i < 16; i++) {
    this$static.c[i] = 0;
  }
  for (i = 0; i < 3; i++) {
    this$static.r[i] = 0;
  }
  arraycopy_0(this$static.c, 0, this$static.u, 0, 15);
  arraycopy_0(this$static.c, 0, this$static.x, 0, 16);
}

function inflate_trees_fixed(bl, bd, tl, td, z){
  $clinit_52();
  bl[0] = 9;
  bd[0] = 5;
  setCheck(tl, 0, fixed_tl);
  setCheck(td, 0, fixed_td);
  return 0;
}

function InfTree(){
}

_ = InfTree.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'InfTree';
_.typeId$ = 0;
_.c = null;
_.hn = null;
_.r = null;
_.u = null;
_.v = null;
_.x = null;
var cpdext, cpdist, cplens, cplext, fixed_td, fixed_tl;
function $$init_6(this$static){
  this$static.was = initDims_0('[J', [0], [(-1)], [1], 0);
}

function $Inflate(this$static){
  $$init_6(this$static);
  return this$static;
}

function $inflate(this$static, z, f){
  var b, r;
  if (z === null || z.istate === null || z.next_in === null)
    return (-2);
  f = f == 4?(-5):0;
  r = (-5);
  while (true) {
    switch (z.istate.mode) {
      case 0:
        if (z.avail_in == 0)
          return r;
        r = f;
        z.avail_in--;
        z.total_in++;
        if (((z.istate.method = z.next_in[z.next_in_index++]) & 15) != 8) {
          z.istate.mode = 13;
          z.msg = 'unknown compression method';
          z.istate.marker = 5;
          break;
        }

        if ((z.istate.method >> 4) + 8 > z.istate.wbits) {
          z.istate.mode = 13;
          z.msg = 'invalid window size';
          z.istate.marker = 5;
          break;
        }

        z.istate.mode = 1;
      case 1:
        if (z.avail_in == 0)
          return r;
        r = f;
        z.avail_in--;
        z.total_in++;
        b = z.next_in[z.next_in_index++] & 255;
        if (((z.istate.method << 8) + b) % 31 != 0) {
          z.istate.mode = 13;
          z.msg = 'incorrect header check';
          z.istate.marker = 5;
          break;
        }

        if ((b & 32) == 0) {
          z.istate.mode = 7;
          break;
        }

        z.istate.mode = 2;
      case 2:
        if (z.avail_in == 0)
          return r;
        r = f;
        z.avail_in--;
        z.total_in++;
        z.istate.need = (z.next_in[z.next_in_index++] & 255) << 24 & 4278190080;
        z.istate.mode = 3;
      case 3:
        if (z.avail_in == 0)
          return r;
        r = f;
        z.avail_in--;
        z.total_in++;
        z.istate.need += (z.next_in[z.next_in_index++] & 255) << 16 & 16711680;
        z.istate.mode = 4;
      case 4:
        if (z.avail_in == 0)
          return r;
        r = f;
        z.avail_in--;
        z.total_in++;
        z.istate.need += (z.next_in[z.next_in_index++] & 255) << 8 & 65280;
        z.istate.mode = 5;
      case 5:
        if (z.avail_in == 0)
          return r;
        r = f;
        z.avail_in--;
        z.total_in++;
        z.istate.need += z.next_in[z.next_in_index++] & 255;
        z.adler = z.istate.need;
        z.istate.mode = 6;
        return 2;
      case 6:
        z.istate.mode = 13;
        z.msg = 'need dictionary';
        z.istate.marker = 0;
        return (-2);
      case 7:
        r = $proc(z.istate.blocks, z, r);
        if (r == (-3)) {
          z.istate.mode = 13;
          z.istate.marker = 0;
          break;
        }

        if (r == 0) {
          r = f;
        }

        if (r != 1) {
          return r;
        }

        r = f;
        $reset_3(z.istate.blocks, z, z.istate.was);
        if (z.istate.nowrap != 0) {
          z.istate.mode = 12;
          break;
        }

        z.istate.mode = 8;
      case 8:
        if (z.avail_in == 0)
          return r;
        r = f;
        z.avail_in--;
        z.total_in++;
        z.istate.need = (z.next_in[z.next_in_index++] & 255) << 24 & 4278190080;
        z.istate.mode = 9;
      case 9:
        if (z.avail_in == 0)
          return r;
        r = f;
        z.avail_in--;
        z.total_in++;
        z.istate.need += (z.next_in[z.next_in_index++] & 255) << 16 & 16711680;
        z.istate.mode = 10;
      case 10:
        if (z.avail_in == 0)
          return r;
        r = f;
        z.avail_in--;
        z.total_in++;
        z.istate.need += (z.next_in[z.next_in_index++] & 255) << 8 & 65280;
        z.istate.mode = 11;
      case 11:
        if (z.avail_in == 0)
          return r;
        r = f;
        z.avail_in--;
        z.total_in++;
        z.istate.need += z.next_in[z.next_in_index++] & 255;
        if (narrow_int(z.istate.was[0]) != narrow_int(z.istate.need)) {
          z.istate.mode = 13;
          z.msg = 'incorrect data check';
          z.istate.marker = 5;
          break;
        }

        z.istate.mode = 12;
      case 12:
        return 1;
      case 13:
        return (-3);
      default:return (-2);
    }
  }
}

function $inflateEnd(this$static, z){
  if (this$static.blocks !== null)
    $free(this$static.blocks, z);
  this$static.blocks = null;
  return 0;
}

function $inflateInit(this$static, z, w){
  z.msg = null;
  this$static.blocks = null;
  this$static.nowrap = 0;
  if (w < 0) {
    w = -w;
    this$static.nowrap = 1;
  }
  if (w < 8 || w > 15) {
    $inflateEnd(this$static, z);
    return (-2);
  }
  this$static.wbits = w;
  z.istate.blocks = $InfBlocks(new InfBlocks(), z, z.istate.nowrap != 0?null:this$static, 1 << w);
  $inflateReset(this$static, z);
  return 0;
}

function $inflateReset(this$static, z){
  if (z === null || z.istate === null)
    return (-2);
  z.total_in = z.total_out = 0;
  z.msg = null;
  z.istate.mode = z.istate.nowrap != 0?7:0;
  $reset_3(z.istate.blocks, z, null);
  return 0;
}

function Inflate(){
}

_ = Inflate.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'Inflate';
_.typeId$ = 0;
_.blocks = null;
_.marker = 0;
_.method = 0;
_.mode = 0;
_.need = 0;
_.nowrap = 0;
_.wbits = 0;
function $clinit_54(){
  $clinit_54 = nullMethod;
  static_ltree = initValues('[S', 0, (-1), [12, 8, 140, 8, 76, 8, 204, 8, 44, 8, 172, 8, 108, 8, 236, 8, 28, 8, 156, 8, 92, 8, 220, 8, 60, 8, 188, 8, 124, 8, 252, 8, 2, 8, 130, 8, 66, 8, 194, 8, 34, 8, 162, 8, 98, 8, 226, 8, 18, 8, 146, 8, 82, 8, 210, 8, 50, 8, 178, 8, 114, 8, 242, 8, 10, 8, 138, 8, 74, 8, 202, 8, 42, 8, 170, 8, 106, 8, 234, 8, 26, 8, 154, 8, 90, 8, 218, 8, 58, 8, 186, 8, 122, 8, 250, 8, 6, 8, 134, 8, 70, 8, 198, 8, 38, 8, 166, 8, 102, 8, 230, 8, 22, 8, 150, 8, 86, 8, 214, 8, 54, 8, 182, 8, 118, 8, 246, 8, 14, 8, 142, 8, 78, 8, 206, 8, 46, 8, 174, 8, 110, 8, 238, 8, 30, 8, 158, 8, 94, 8, 222, 8, 62, 8, 190, 8, 126, 8, 254, 8, 1, 8, 129, 8, 65, 8, 193, 8, 33, 8, 161, 8, 97, 8, 225, 8, 17, 8, 145, 8, 81, 8, 209, 8, 49, 8, 177, 8, 113, 8, 241, 8, 9, 8, 137, 8, 73, 8, 201, 8, 41, 8, 169, 8, 105, 8, 233, 8, 25, 8, 153, 8, 89, 8, 217, 8, 57, 8, 185, 8, 121, 8, 249, 8, 5, 8, 133, 8, 69, 8, 197, 8, 37, 8, 165, 8, 101, 8, 229, 8, 21, 8, 149, 8, 85, 8, 213, 8, 53, 8, 181, 8, 117, 8, 245, 8, 13, 8, 141, 8, 77, 8, 205, 8, 45, 8, 173, 8, 109, 8, 237, 8, 29, 8, 157, 8, 93, 8, 221, 8, 61, 8, 189, 8, 125, 8, 253, 8, 19, 9, 275, 9, 147, 9, 403, 9, 83, 9, 339, 9, 211, 9, 467, 9, 51, 9, 307, 9, 179, 9, 435, 9, 115, 9, 371, 9, 243, 9, 499, 9, 11, 9, 267, 9, 139, 9, 395, 9, 75, 9, 331, 9, 203, 9, 459, 9, 43, 9, 299, 9, 171, 9, 427, 9, 107, 9, 363, 9, 235, 9, 491, 9, 27, 9, 283, 9, 155, 9, 411, 9, 91, 9, 347, 9, 219, 9, 475, 9, 59, 9, 315, 9, 187, 9, 443, 9, 123, 9, 379, 9, 251, 9, 507, 9, 7, 9, 263, 9, 135, 9, 391, 9, 71, 9, 327, 9, 199, 9, 455, 9, 39, 9, 295, 9, 167, 9, 423, 9, 103, 9, 359, 9, 231, 9, 487, 9, 23, 9, 279, 9, 151, 9, 407, 9, 87, 9, 343, 9, 215, 9, 471, 9, 55, 9, 311, 9, 183, 9, 439, 9, 119, 9, 375, 9, 247, 9, 503, 9, 15, 9, 271, 9, 143, 9, 399, 9, 79, 9, 335, 9, 207, 9, 463, 9, 47, 9, 303, 9, 175, 9, 431, 9, 111, 9, 367, 9, 239, 9, 495, 9, 31, 9, 287, 9, 159, 9, 415, 9, 95, 9, 351, 9, 223, 9, 479, 9, 63, 9, 319, 9, 191, 9, 447, 9, 127, 9, 383, 9, 255, 9, 511, 9, 0, 7, 64, 7, 32, 7, 96, 7, 16, 7, 80, 7, 48, 7, 112, 7, 8, 7, 72, 7, 40, 7, 104, 7, 24, 7, 88, 7, 56, 7, 120, 7, 4, 7, 68, 7, 36, 7, 100, 7, 20, 7, 84, 7, 52, 7, 116, 7, 3, 8, 131, 8, 67, 8, 195, 8, 35, 8, 163, 8, 99, 8, 227, 8]);
  static_dtree = initValues('[S', 0, (-1), [0, 5, 16, 5, 8, 5, 24, 5, 4, 5, 20, 5, 12, 5, 28, 5, 2, 5, 18, 5, 10, 5, 26, 5, 6, 5, 22, 5, 14, 5, 30, 5, 1, 5, 17, 5, 9, 5, 25, 5, 5, 5, 21, 5, 13, 5, 29, 5, 3, 5, 19, 5, 11, 5, 27, 5, 7, 5, 23, 5]);
  static_l_desc = $StaticTree(new StaticTree(), static_ltree, ($clinit_55() , extra_lbits), 257, 286, 15);
  static_d_desc = $StaticTree(new StaticTree(), static_dtree, ($clinit_55() , extra_dbits), 0, 30, 15);
  static_bl_desc = $StaticTree(new StaticTree(), null, ($clinit_55() , extra_blbits), 0, 19, 7);
}

function $StaticTree(this$static, static_tree, extra_bits, extra_base, elems, max_length){
  $clinit_54();
  this$static.static_tree = static_tree;
  this$static.extra_bits = extra_bits;
  this$static.extra_base = extra_base;
  this$static.elems = elems;
  this$static.max_length = max_length;
  return this$static;
}

function StaticTree(){
}

_ = StaticTree.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'StaticTree';
_.typeId$ = 0;
_.elems = 0;
_.extra_base = 0;
_.extra_bits = null;
_.max_length = 0;
_.static_tree = null;
var static_bl_desc, static_d_desc, static_dtree, static_l_desc, static_ltree;
function $clinit_55(){
  $clinit_55 = nullMethod;
  extra_lbits = initValues('[I', 19, (-1), [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]);
  extra_dbits = initValues('[I', 19, (-1), [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);
  extra_blbits = initValues('[I', 19, (-1), [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]);
  bl_order = initValues('[B', 0, (-1), [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
  _dist_code = initValues('[B', 0, (-1), [0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, 18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29]);
  _length_code = initValues('[B', 0, (-1), [0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28]);
  base_length = initValues('[I', 19, (-1), [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 0]);
  base_dist = initValues('[I', 19, (-1), [0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576]);
}

function $Tree(this$static){
  $clinit_55();
  return this$static;
}

function $build_tree(this$static, s){
  var elems, m, max_code, n, node, stree, tree;
  tree = this$static.dyn_tree;
  stree = this$static.stat_desc.static_tree;
  elems = this$static.stat_desc.elems;
  max_code = (-1);
  s.heap_len = 0;
  s.heap_max = 573;
  for (n = 0; n < elems; n++) {
    if (tree[n * 2] != 0) {
      s.heap[++s.heap_len] = max_code = n;
      s.depth[n] = 0;
    }
     else {
      tree[n * 2 + 1] = 0;
    }
  }
  while (s.heap_len < 2) {
    node = s.heap[++s.heap_len] = max_code < 2?++max_code:0;
    tree[node * 2] = 1;
    s.depth[node] = 0;
    s.opt_len--;
    if (stree !== null)
      s.static_len -= stree[node * 2 + 1];
  }
  this$static.max_code = max_code;
  for (n = round_int(s.heap_len / 2); n >= 1; n--)
    $pqdownheap(s, tree, n);
  node = elems;
  do {
    n = s.heap[1];
    s.heap[1] = s.heap[s.heap_len--];
    $pqdownheap(s, tree, 1);
    m = s.heap[1];
    s.heap[--s.heap_max] = n;
    s.heap[--s.heap_max] = m;
    tree[node * 2] = narrow_short(tree[n * 2] + tree[m * 2]);
    s.depth[node] = narrow_byte(max(s.depth[n], s.depth[m]) + 1);
    tree[n * 2 + 1] = tree[m * 2 + 1] = narrow_short(node);
    s.heap[1] = node++;
    $pqdownheap(s, tree, 1);
  }
   while (s.heap_len >= 2);
  s.heap[--s.heap_max] = s.heap[1];
  $gen_bitlen(this$static, s);
  gen_codes(tree, max_code, s.bl_count);
}

function $gen_bitlen(this$static, s){
  var base, bits, extra, f, h, m, max_length, n, overflow, stree, tree, xbits;
  tree = this$static.dyn_tree;
  stree = this$static.stat_desc.static_tree;
  extra = this$static.stat_desc.extra_bits;
  base = this$static.stat_desc.extra_base;
  max_length = this$static.stat_desc.max_length;
  overflow = 0;
  for (bits = 0; bits <= 15; bits++)
    s.bl_count[bits] = 0;
  tree[s.heap[s.heap_max] * 2 + 1] = 0;
  for (h = s.heap_max + 1; h < 573; h++) {
    n = s.heap[h];
    bits = tree[tree[n * 2 + 1] * 2 + 1] + 1;
    if (bits > max_length) {
      bits = max_length;
      overflow++;
    }
    tree[n * 2 + 1] = narrow_short(bits);
    if (n > this$static.max_code)
      continue;
    s.bl_count[bits]++;
    xbits = 0;
    if (n >= base)
      xbits = extra[n - base];
    f = tree[n * 2];
    s.opt_len += f * (bits + xbits);
    if (stree !== null)
      s.static_len += f * (stree[n * 2 + 1] + xbits);
  }
  if (overflow == 0)
    return;
  do {
    bits = max_length - 1;
    while (s.bl_count[bits] == 0)
      bits--;
    s.bl_count[bits]--;
    s.bl_count[bits + 1] += 2;
    s.bl_count[max_length]--;
    overflow -= 2;
  }
   while (overflow > 0);
  for (bits = max_length; bits != 0; bits--) {
    n = s.bl_count[bits];
    while (n != 0) {
      m = s.heap[--h];
      if (m > this$static.max_code)
        continue;
      if (tree[m * 2 + 1] != bits) {
        s.opt_len += (bits - tree[m * 2 + 1]) * tree[m * 2];
        tree[m * 2 + 1] = narrow_short(bits);
      }
      n--;
    }
  }
}

function bi_reverse(code, len){
  $clinit_55();
  var res;
  res = 0;
  do {
    res |= code & 1;
    code >>>= 1;
    res <<= 1;
  }
   while (--len > 0);
  return res >>> 1;
}

function d_code(dist){
  $clinit_55();
  return dist < 256?_dist_code[dist]:_dist_code[256 + (dist >>> 7)];
}

function gen_codes(tree, max_code, bl_count){
  $clinit_55();
  var bits, code, len, n, next_code;
  next_code = initDims_0('[S', [0], [(-1)], [16], 0);
  code = 0;
  for (bits = 1; bits <= 15; bits++) {
    next_code[bits] = code = narrow_short(code + bl_count[bits - 1] << 1);
  }
  for (n = 0; n <= max_code; n++) {
    len = tree[n * 2 + 1];
    if (len == 0)
      continue;
    tree[n * 2] = narrow_short(bi_reverse(next_code[len]++, len));
  }
}

function Tree(){
}

_ = Tree.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'Tree';
_.typeId$ = 0;
_.dyn_tree = null;
_.max_code = 0;
_.stat_desc = null;
var _dist_code, _length_code, base_dist, base_length, bl_order, extra_blbits, extra_dbits, extra_lbits;
function XInputStream(){
}

_ = XInputStream.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_util_ + 'XInputStream';
_.typeId$ = 0;
function $$init_7(this$static){
  this$static.z = $ZStream(new ZStream());
  this$static.buf = initDims_0('[B', [0], [(-1)], [this$static.bufsize], 0);
  this$static.buf1 = initDims_0('[B', [0], [(-1)], [1], 0);
}

function $ZInputStream(this$static, in_$, nowrap){
  $$init_7(this$static);
  this$static.in_$ = in_$;
  $inflateInit_1(this$static.z, nowrap);
  this$static.compress = false;
  this$static.z.next_in = this$static.buf;
  this$static.z.next_in_index = 0;
  this$static.z.avail_in = 0;
  return this$static;
}

function $read(this$static){
  if ($read_0(this$static, this$static.buf1, 0, 1) == (-1))
    return (-1);
  return this$static.buf1[0] & 255;
}

function $read_0(this$static, b, off, len){
  var err;
  if (len == 0)
    return 0;
  this$static.z.next_out = b;
  this$static.z.next_out_index = off;
  this$static.z.avail_out = len;
  do {
    if (this$static.z.avail_in == 0 && !this$static.nomoreinput) {
      this$static.z.next_in_index = 0;
      this$static.z.avail_in = $read_1(this$static.in_$, this$static.buf, 0, this$static.bufsize);
      if (this$static.z.avail_in == (-1)) {
        this$static.z.avail_in = 0;
        this$static.nomoreinput = true;
      }
    }
    if (this$static.compress)
      err = $deflate_0(this$static.z, this$static.flush);
    else 
      err = $inflate_0(this$static.z, this$static.flush);
    if (this$static.nomoreinput && err == (-5))
      return (-1);
    if (err != 0 && err != 1)
      throw $ZStreamException(new ZStreamException(), (this$static.compress?'de':'in') + 'flating: ' + this$static.z.msg);
    if ((this$static.nomoreinput || err == 1) && this$static.z.avail_out == len)
      return (-1);
  }
   while (this$static.z.avail_out == len && err == 0);
  return len - this$static.z.avail_out;
}

function ZInputStream(){
}

_ = ZInputStream.prototype = new XInputStream();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'ZInputStream';
_.typeId$ = 0;
_.bufsize = 512;
_.compress = false;
_.flush = 0;
_.in_$ = null;
_.nomoreinput = false;
function $write_1(this$static, b){
  $write(this$static, b, 0, b.length_0);
}

function flush_1(){
}

function XOutputStream(){
}

_ = XOutputStream.prototype = new Object_0();
_.flush_0 = flush_1;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_util_ + 'XOutputStream';
_.typeId$ = 0;
function $$init_8(this$static){
  this$static.z = $ZStream(new ZStream());
  this$static.buf = initDims_0('[B', [0], [(-1)], [this$static.bufsize], 0);
}

function $ZOutputStream(this$static, out, level, nowrap){
  $$init_8(this$static);
  this$static.out = out;
  $deflateInit_1(this$static.z, level, nowrap);
  this$static.compress = true;
  return this$static;
}

function $close(this$static){
  var $e0;
  try {
    try {
      $finish_0(this$static);
    }
     catch ($e0) {
      $e0 = caught($e0);
      if (instanceOf($e0, 10)) {
      }
       else 
        throw $e0;
    }
  }
   finally {
    $end(this$static);
    this$static.out = null;
  }
}

function $end(this$static){
  if (this$static.z === null)
    return;
  if (this$static.compress) {
    $deflateEnd_0(this$static.z);
  }
   else {
    $inflateEnd_0(this$static.z);
  }
  $free_0(this$static.z);
  this$static.z = null;
}

function $finish_0(this$static){
  var err;
  do {
    this$static.z.next_out = this$static.buf;
    this$static.z.next_out_index = 0;
    this$static.z.avail_out = this$static.bufsize;
    if (this$static.compress) {
      err = $deflate_0(this$static.z, 4);
    }
     else {
      err = $inflate_0(this$static.z, 4);
    }
    if (err != 1 && err != 0)
      throw $ZStreamException(new ZStreamException(), (this$static.compress?'de':'in') + 'flating: ' + this$static.z.msg);
    if (this$static.bufsize - this$static.z.avail_out > 0) {
      $write_0(this$static.out, this$static.buf, 0, this$static.bufsize - this$static.z.avail_out);
    }
  }
   while (this$static.z.avail_in > 0 || this$static.z.avail_out == 0);
  $flush(this$static);
}

function $flush(this$static){
  this$static.out.flush_0();
}

function $write(this$static, b, off, len){
  var err;
  if (len == 0)
    return;
  this$static.z.next_in = b;
  this$static.z.next_in_index = off;
  this$static.z.avail_in = len;
  do {
    this$static.z.next_out = this$static.buf;
    this$static.z.next_out_index = 0;
    this$static.z.avail_out = this$static.bufsize;
    if (this$static.compress)
      err = $deflate_0(this$static.z, this$static.flush);
    else 
      err = $inflate_0(this$static.z, this$static.flush);
    if (err != 0)
      throw $ZStreamException(new ZStreamException(), (this$static.compress?'de':'in') + 'flating: ' + this$static.z.msg);
    $write_0(this$static.out, this$static.buf, 0, this$static.bufsize - this$static.z.avail_out);
  }
   while (this$static.z.avail_in > 0 || this$static.z.avail_out == 0);
}

function flush_0(){
  $flush(this);
}

function ZOutputStream(){
}

_ = ZOutputStream.prototype = new XOutputStream();
_.flush_0 = flush_0;
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'ZOutputStream';
_.typeId$ = 0;
_.bufsize = 512;
_.compress = false;
_.flush = 0;
_.out = null;
function $$init_9(this$static){
  this$static._adler = new Adler32();
}

function $ZStream(this$static){
  $$init_9(this$static);
  return this$static;
}

function $deflate_0(this$static, flush){
  if (this$static.dstate === null) {
    return (-2);
  }
  return $deflate(this$static.dstate, this$static, flush);
}

function $deflateEnd_0(this$static){
  var ret;
  if (this$static.dstate === null)
    return (-2);
  ret = $deflateEnd(this$static.dstate);
  this$static.dstate = null;
  return ret;
}

function $deflateInit_1(this$static, level, nowrap){
  return $deflateInit_0(this$static, level, 15, nowrap);
}

function $deflateInit_0(this$static, level, bits, nowrap){
  this$static.dstate = $Deflate(new Deflate());
  return $deflateInit(this$static.dstate, this$static, level, nowrap?-bits:bits);
}

function $flush_pending(this$static){
  var len;
  len = this$static.dstate.pending;
  if (len > this$static.avail_out)
    len = this$static.avail_out;
  if (len == 0)
    return;
  if (this$static.dstate.pending_buf.length_0 <= this$static.dstate.pending_out || this$static.next_out.length_0 <= this$static.next_out_index || this$static.dstate.pending_buf.length_0 < this$static.dstate.pending_out + len || this$static.next_out.length_0 < this$static.next_out_index + len) {
    $clinit_26() , out_0;
    $clinit_26() , out_0;
  }
  arraycopy(this$static.dstate.pending_buf, this$static.dstate.pending_out, this$static.next_out, this$static.next_out_index, len);
  this$static.next_out_index += len;
  this$static.dstate.pending_out += len;
  this$static.total_out += len;
  this$static.avail_out -= len;
  this$static.dstate.pending -= len;
  if (this$static.dstate.pending == 0) {
    this$static.dstate.pending_out = 0;
  }
}

function $free_0(this$static){
  this$static.next_in = null;
  this$static.next_out = null;
  this$static.msg = null;
  this$static._adler = null;
}

function $inflate_0(this$static, f){
  if (this$static.istate === null)
    return (-2);
  return $inflate(this$static.istate, this$static, f);
}

function $inflateEnd_0(this$static){
  var ret;
  if (this$static.istate === null)
    return (-2);
  ret = $inflateEnd(this$static.istate, this$static);
  this$static.istate = null;
  return ret;
}

function $inflateInit_1(this$static, nowrap){
  return $inflateInit_0(this$static, 15, nowrap);
}

function $inflateInit_0(this$static, w, nowrap){
  this$static.istate = $Inflate(new Inflate());
  return $inflateInit(this$static.istate, this$static, nowrap?-w:w);
}

function $read_buf(this$static, buf, start, size){
  var len;
  len = this$static.avail_in;
  if (len > size)
    len = size;
  if (len == 0)
    return 0;
  this$static.avail_in -= len;
  if (this$static.dstate.noheader == 0) {
    this$static.adler = $adler32(this$static._adler, this$static.adler, this$static.next_in, this$static.next_in_index, len);
  }
  arraycopy(this$static.next_in, this$static.next_in_index, buf, start, len);
  this$static.next_in_index += len;
  this$static.total_in += len;
  return len;
}

function ZStream(){
}

_ = ZStream.prototype = new Object_0();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'ZStream';
_.typeId$ = 0;
_.adler = 0;
_.avail_in = 0;
_.avail_out = 0;
_.data_type = 0;
_.dstate = null;
_.istate = null;
_.msg = null;
_.next_in = null;
_.next_in_index = 0;
_.next_out = null;
_.next_out_index = 0;
_.total_in = 0;
_.total_out = 0;
function $IOXException(this$static, s){
  $Exception(this$static, s);
  return this$static;
}

function IOXException(){
}

_ = IOXException.prototype = new Exception();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_util_ + 'IOXException';
_.typeId$ = 17;
function $ZStreamException(this$static, s){
  $IOXException(this$static, s);
  return this$static;
}

function ZStreamException(){
}

_ = ZStreamException.prototype = new IOXException();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_jzlib_ + 'ZStreamException';
_.typeId$ = 18;
function $ByteArrayInputStream(this$static, buf){
  this$static.buf = buf;
  this$static.pos = 0;
  this$static.count = buf.length_0;
  return this$static;
}

function $read_1(this$static, b, off, len){
  if (b === null) {
    throw new NullPointerException();
  }
   else if (off < 0 || off > b.length_0 || len < 0 || off + len > b.length_0 || off + len < 0) {
    throw new IndexOutOfBoundsException();
  }
  if (this$static.pos >= this$static.count) {
    return (-1);
  }
  if (this$static.pos + len > this$static.count) {
    len = this$static.count - this$static.pos;
  }
  if (len <= 0) {
    return 0;
  }
  arraycopy(this$static.buf, this$static.pos, b, off, len);
  this$static.pos += len;
  return len;
}

function ByteArrayInputStream(){
}

_ = ByteArrayInputStream.prototype = new XInputStream();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_util_ + 'ByteArrayInputStream';
_.typeId$ = 0;
_.buf = null;
_.count = 0;
_.pos = 0;
function $ByteArrayOutputStream(this$static){
  $ByteArrayOutputStream_0(this$static, 32);
  return this$static;
}

function $ByteArrayOutputStream_0(this$static, size){
  if (size < 0) {
    throw $IllegalArgumentException(new IllegalArgumentException(), 'Negative initial size: ' + size);
  }
  this$static.buf = initDims_0('[B', [0], [(-1)], [size], 0);
  return this$static;
}

function $toByteArray(this$static){
  var newbuf;
  newbuf = initDims_0('[B', [0], [(-1)], [this$static.count], 0);
  arraycopy(this$static.buf, 0, newbuf, 0, this$static.count);
  return newbuf;
}

function $write_0(this$static, b, off, len){
  var newbuf, newcount;
  if (off < 0 || off > b.length_0 || len < 0 || off + len > b.length_0 || off + len < 0) {
    throw new IndexOutOfBoundsException();
  }
   else if (len == 0) {
    return;
  }
  newcount = this$static.count + len;
  if (newcount > this$static.buf.length_0) {
    newbuf = initDims_0('[B', [0], [(-1)], [max(this$static.buf.length_0 << 1, newcount)], 0);
    arraycopy(this$static.buf, 0, newbuf, 0, this$static.count);
    this$static.buf = newbuf;
  }
  arraycopy(b, off, this$static.buf, this$static.count, len);
  this$static.count = newcount;
}

function ByteArrayOutputStream(){
}

_ = ByteArrayOutputStream.prototype = new XOutputStream();
_.typeName$ = package_org_emergent_lucidity_lucifer_client_util_ + 'ByteArrayOutputStream';
_.typeId$ = 0;
_.buf = null;
_.count = 0;
function init(){
  $onModuleLoad(new Lucifer());
}

function gwtOnLoad(errFn, modName, modBase){
  $moduleName = modName;
  $moduleBase = modBase;
  if (errFn)
    try {
      init();
    }
     catch (e) {
      errFn(modName);
    }
   else {
    init();
  }
}

var typeIdArray = [{}, {}, {1:1}, {3:1}, {3:1, 4:1}, {3:1, 4:1}, {3:1, 4:1}, {2:1}, {3:1, 4:1}, {3:1, 4:1}, {3:1, 4:1}, {3:1, 4:1}, {3:1, 4:1}, {3:1, 4:1}, {3:1, 4:1}, {3:1, 4:1}, {5:1, 6:1}, {3:1, 4:1, 10:1}, {3:1, 4:1, 10:1}, {7:1, 9:1}];

if (org_emergent_lucidity_lucifer_Lucifer) {
  var __gwt_initHandlers = org_emergent_lucidity_lucifer_Lucifer.__gwt_initHandlers;  org_emergent_lucidity_lucifer_Lucifer.onScriptLoad(getLuciferInstance);
}
})();
